@skyux/core 12.27.0 → 13.0.0-alpha.1

package/index.d.ts

@@ -1,96 +1,1658 @@
-export { SkyCoreAdapterModule } from './lib/modules/adapter-service/adapter.module';
-export { SkyCoreAdapterService } from './lib/modules/adapter-service/adapter.service';
-export { SkyFocusableChildrenOptions } from './lib/modules/adapter-service/focusable-children-options';
-export { SkyAffixAutoFitContext } from './lib/modules/affix/affix-auto-fit-context';
-export { SkyAffixConfig } from './lib/modules/affix/affix-config';
-export { SkyAffixHorizontalAlignment } from './lib/modules/affix/affix-horizontal-alignment';
-export { SkyAffixOffset } from './lib/modules/affix/affix-offset';
-export { SkyAffixOffsetChange } from './lib/modules/affix/affix-offset-change';
-export { SkyAffixPlacement } from './lib/modules/affix/affix-placement';
-export { SkyAffixPlacementChange } from './lib/modules/affix/affix-placement-change';
-export { SkyAffixPosition } from './lib/modules/affix/affix-position';
-export { SkyAffixVerticalAlignment } from './lib/modules/affix/affix-vertical-alignment';
-export { SkyAffixModule } from './lib/modules/affix/affix.module';
-export { SkyAffixService } from './lib/modules/affix/affix.service';
-export { SkyAffixer } from './lib/modules/affix/affixer';
-export { SkyContentInfo } from './lib/modules/content-info-provider/content-info';
-export { SkyContentInfoDescriptor } from './lib/modules/content-info-provider/content-info-descriptor';
-export { SkyContentInfoProvider } from './lib/modules/content-info-provider/content-info-provider';
-export { SkyDefaultInputProvider } from './lib/modules/default-input-provider/default-input-provider';
-export { SkyDockInsertComponentConfig } from './lib/modules/dock/dock-insert-component-config';
-export { SkyDockItem } from './lib/modules/dock/dock-item';
-export { SkyDockItemConfig } from './lib/modules/dock/dock-item-config';
-export { SkyDockLocation } from './lib/modules/dock/dock-location';
-export { SkyDockOptions } from './lib/modules/dock/dock-options';
-export { SkyDockModule } from './lib/modules/dock/dock.module';
-export { SkyDockService } from './lib/modules/dock/dock.service';
-export { SkyDynamicComponentLocation } from './lib/modules/dynamic-component/dynamic-component-location';
-export { SkyDynamicComponentOptions } from './lib/modules/dynamic-component/dynamic-component-options';
-export { SkyDynamicComponentModule } from './lib/modules/dynamic-component/dynamic-component.module';
-export { SkyDynamicComponentLegacyService, SkyDynamicComponentService, } from './lib/modules/dynamic-component/dynamic-component.service';
-export { SkyFileReaderService } from './lib/modules/file-reader/file-reader.service';
-export { SkyAppFormat } from './lib/modules/format/app-format';
-export { SkyHelpGlobalOptions } from './lib/modules/help/help-global-options';
-export { SKY_HELP_GLOBAL_OPTIONS } from './lib/modules/help/help-global-options-token';
-export { SkyHelpOpenArgs } from './lib/modules/help/help-open-args';
-export { SkyHelpUpdateArgs } from './lib/modules/help/help-update-args';
-export { SkyHelpService } from './lib/modules/help/help.service';
-export { SkyIdModule } from './lib/modules/id/id.module';
-export { SkyIdService } from './lib/modules/id/id.service';
-export { SkyLayoutHostForChildArgs } from './lib/modules/layout-host/layout-host-for-child-args';
-export { SkyLayoutHostDirective } from './lib/modules/layout-host/layout-host.directive';
-export { SkyLayoutHostService } from './lib/modules/layout-host/layout-host.service';
-export { SkyLiveAnnouncerService } from './lib/modules/live-announcer/live-announcer.service';
-export { SkyLiveAnnouncerArgs } from './lib/modules/live-announcer/types/live-announcer-args';
-export { SkyLiveAnnouncerPoliteness } from './lib/modules/live-announcer/types/live-announcer-politeness';
-export { SkyLogModule } from './lib/modules/log/log.module';
-export { SkyLogService } from './lib/modules/log/log.service';
-export { SkyLogLevel } from './lib/modules/log/types/log-level';
-export { SKY_LOG_LEVEL } from './lib/modules/log/types/log-level-token';
-export { SKY_BREAKPOINTS, SkyBreakpoint, } from './lib/modules/breakpoint-observer/breakpoint';
-export { SkyBreakpointObserver } from './lib/modules/breakpoint-observer/breakpoint-observer';
-export { SKY_BREAKPOINT_OBSERVER } from './lib/modules/breakpoint-observer/breakpoint-observer.token';
-export { SkyContainerBreakpointObserver } from './lib/modules/breakpoint-observer/container-breakpoint-observer';
-export { SkyMediaBreakpointObserver } from './lib/modules/breakpoint-observer/media-breakpoint-observer';
-export { provideSkyBreakpointObserver } from './lib/modules/breakpoint-observer/provide-breakpoint-observer';
-export { SkyResponsiveHostDirective } from './lib/modules/breakpoint-observer/responsive-host.directive';
-export { SkyMediaBreakpoints } from './lib/modules/media-query/media-breakpoints';
-export { SkyMediaQueryListener } from './lib/modules/media-query/media-query-listener';
-export { SkyMediaQueryModule } from './lib/modules/media-query/media-query.module';
-export { SkyMediaQueryService } from './lib/modules/media-query/media-query.service';
-export { SkyMutationObserverService } from './lib/modules/mutation/mutation-observer-service';
-export { SkyNumericSymbol } from './lib/modules/numeric/numeric-symbol';
-export { SkyNumericModule } from './lib/modules/numeric/numeric.module';
-export { NumericOptions, SkyNumericOptions, } from './lib/modules/numeric/numeric.options';
-export { SkyNumericPipe } from './lib/modules/numeric/numeric.pipe';
-export { SkyNumericService } from './lib/modules/numeric/numeric.service';
-export { SkyOverlayConfig } from './lib/modules/overlay/overlay-config';
-export { SkyOverlayInstance } from './lib/modules/overlay/overlay-instance';
-export { SkyOverlayPosition } from './lib/modules/overlay/overlay-position';
-export { SkyOverlayModule } from './lib/modules/overlay/overlay.module';
-export { SkyOverlayLegacyService, SkyOverlayService, } from './lib/modules/overlay/overlay.service';
-export { SkyPercentPipeModule } from './lib/modules/percent-pipe/percent-pipe.module';
-export { SkyPercentPipe } from './lib/modules/percent-pipe/percent.pipe';
-export { SkyResizeObserverMediaQueryService } from './lib/modules/resize-observer/resize-observer-media-query.service';
-export { SkyResizeObserverService } from './lib/modules/resize-observer/resize-observer.service';
-export { SkyScreenReaderLabelDirective } from './lib/modules/screen-reader-label/screen-reader-label.directive';
-export { SkyScrollShadowEventArgs } from './lib/modules/scroll-shadow/scroll-shadow-event-args';
-export { SkyScrollShadowDirective } from './lib/modules/scroll-shadow/scroll-shadow.directive';
-export { SkyScrollableHostService } from './lib/modules/scrollable-host/scrollable-host.service';
-export { SkyStackingContext } from './lib/modules/stacking-context/stacking-context';
-export { SKY_STACKING_CONTEXT } from './lib/modules/stacking-context/stacking-context-token';
-export { SkyAppSetTitleArgs } from './lib/modules/title/set-title-args';
-export { SkyAppTitleService } from './lib/modules/title/title.service';
-export { SkyTrimModule } from './lib/modules/trim/trim.module';
-export { SkyUIConfigService } from './lib/modules/ui-config/ui-config.service';
-export { SkyViewkeeper } from './lib/modules/viewkeeper/viewkeeper';
-export { SkyViewkeeperHostOptions } from './lib/modules/viewkeeper/viewkeeper-host-options';
-export { SkyViewkeeperOptions } from './lib/modules/viewkeeper/viewkeeper-options';
-export { SkyViewkeeperModule } from './lib/modules/viewkeeper/viewkeeper.module';
-export { SkyViewkeeperService } from './lib/modules/viewkeeper/viewkeeper.service';
-export { SkyAppWindowRef } from './lib/modules/window/window-ref';
-export { VERSION } from './version';
-export { SkyAffixDirective as λ1 } from './lib/modules/affix/affix.directive';
-export { SkyIdDirective as λ2 } from './lib/modules/id/id.directive';
-export { SkyTrimDirective as λ4 } from './lib/modules/trim/trim.directive';
-export { SkyViewkeeperDirective as λ3 } from './lib/modules/viewkeeper/viewkeeper.directive';
+import * as i0 from '@angular/core';
+import { RendererFactory2, ElementRef, Renderer2, NgZone, OnDestroy, OnInit, OnChanges, EventEmitter, SimpleChanges, StaticProvider, Type, ViewContainerRef, EnvironmentInjector, ApplicationRef, ComponentRef, InjectionToken, Provider, Injector, PipeTransform, ChangeDetectorRef, TemplateRef, EmbeddedViewRef, AfterViewInit } from '@angular/core';
+import { ViewportRuler } from '@angular/cdk/overlay';
+import { Observable, ReplaySubject, Subscription } from 'rxjs';
+import * as i2 from '@angular/common';
+import * as i1 from '@skyux/i18n';
+import { SkyLibResourcesService, SkyAppLocaleProvider } from '@skyux/i18n';
+import { Title } from '@angular/platform-browser';
+
+/**
+ * @deprecated The `SkyCoreAdapterService` no longer needs the `SkyCoreAdapterModule`.
+ * The `SkyCoreAdapterModule` can be removed from your project.
+ */
+declare class SkyCoreAdapterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyCoreAdapterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyCoreAdapterModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyCoreAdapterModule>;
+}
+
+/**
+ * A list of all breakpoints.
+ * @internal
+ */
+declare const SKY_BREAKPOINTS: readonly ["xs", "sm", "md", "lg"];
+/**
+ * The name of a viewport or container breakpoint.
+ */
+type SkyBreakpoint = (typeof SKY_BREAKPOINTS)[number];
+
+/**
+ * Represents all available media breakpoints.
+ * @deprecated Use `SkyBreakpoint` instead.
+ */
+declare enum SkyMediaBreakpoints {
+    /**
+     * Screen widths of 767px or less.
+     */
+    xs = 1,
+    /**
+     * Screen widths of 768px to 991px.
+     */
+    sm = 2,
+    /**
+     * Screen widths of 992px to 1199px.
+     */
+    md = 3,
+    /**
+     * Screen widths of 1200px or greater.
+     */
+    lg = 4
+}
+
+/**
+ * Options for getting focusable children.
+ */
+interface SkyFocusableChildrenOptions {
+    /**
+     * By default, the `getFocusableChildren()` function will filter out elements with
+     * a `tabIndex` of `-1`. Setting `ignoreTabIndex = true` will ignore this filter.
+     */
+    ignoreTabIndex?: boolean;
+    /**
+     * By default, the `getFocusableChildren()` function will only return visible elements.
+     * Setting `ignoreVisibility = true` will ignore this filter.
+     */
+    ignoreVisibility?: boolean;
+}
+
+declare class SkyCoreAdapterService {
+    #private;
+    constructor(rendererFactory: RendererFactory2);
+    /**
+     * Set the responsive container CSS class for a given element.
+     *
+     * @param elementRef - The element that will receive the new CSS class.
+     * @param breakpoint - The breakpoint to determine which class gets set.
+     * For example a breakpoint of "xs" will set a CSS class of "sky-responsive-container-xs".
+     * @deprecated Use the `SkyResponsiveHostDirective` instead.
+     */
+    setResponsiveContainerClass(elementRef: ElementRef, breakpoint: SkyBreakpoint | SkyMediaBreakpoints): void;
+    /**
+     * This method temporarily enables/disables pointer events.
+     * This is helpful to prevent iFrames from interfering with drag events.
+     *
+     * @param enable - Set to `true` to enable pointer events. Set to `false` to disable.
+     */
+    toggleIframePointerEvents(enable: boolean): void;
+    /**
+     * Focuses on the first element found with an `autofocus` attribute inside the supplied `elementRef`.
+     *
+     * @param elementRef - The element to search within.
+     * @return Returns `true` if a child element with autofocus is found.
+     */
+    applyAutoFocus(elementRef?: ElementRef): boolean;
+    /**
+     * Sets focus on the first focusable child of the `elementRef` parameter.
+     * If no focusable children are found, and `focusOnContainerIfNoChildrenFound` is `true`,
+     * focus will be set on the container element.
+     *
+     * @param elementRef - The element to search within.
+     * @param containerSelector - A CSS selector indicating the container that should
+     * receive focus if no focusable children are found.
+     * @param focusOnContainerIfNoChildrenFound - It set to `true`, the container will
+     * receive focus if no focusable children are found.
+     */
+    getFocusableChildrenAndApplyFocus(elementRef: ElementRef, containerSelector?: string, focusOnContainerIfNoChildrenFound?: boolean): void;
+    /**
+     * Returns an array of all focusable children of provided `element`.
+     *
+     * @param element - The HTMLElement to search within.
+     * @param options - Options for getting focusable children.
+     */
+    getFocusableChildren(element?: HTMLElement, options?: SkyFocusableChildrenOptions): HTMLElement[];
+    /**
+     * Returns the clientWidth of the provided elementRef.
+     * @param elementRef - The element to calculate width from.
+     */
+    getWidth(elementRef: ElementRef): number;
+    /**
+     * Checks if an event target has a higher z-index than a given element.
+     * @param target The event target element.
+     * @param element The element to test against. A z-index must be explicitly set for this element.
+     */
+    isTargetAboveElement(target: EventTarget, element: HTMLElement): boolean;
+    /**
+     * Remove inline height styles from the provided elements.
+     * @param elementRef - The element to search within.
+     * @param selector - The CSS selector to use when finding elements for removing height.
+     */
+    resetHeight(elementRef: ElementRef, selector: string): void;
+    /**
+     * Sets all element heights to match the height of the tallest element.
+     * @param elementRef - The element to search within.
+     * @param selector - The CSS selector to use when finding elements for syncing height.
+     */
+    syncMaxHeight(elementRef: ElementRef, selector: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyCoreAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyCoreAdapterService>;
+}
+
+declare enum SkyAffixAutoFitContext {
+    /**
+     * Auto-fit functionality will respect the nearest overflow parent element's dimensions.
+     */
+    OverflowParent = 0,
+    /**
+     * Auto-fit functionality will respect the browser viewport dimensions.
+     */
+    Viewport = 1
+}
+
+/**
+ * The horizontal alignment of the affixed element to the base element.
+ */
+type SkyAffixHorizontalAlignment = 'left' | 'center' | 'right';
+
+/**
+ * Offset values used by the affixer.
+ */
+interface SkyAffixOffset {
+    bottom?: number;
+    left?: number;
+    right?: number;
+    top?: number;
+}
+
+/**
+ * The placement of the affixed element around the base element.
+ */
+type SkyAffixPlacement = 'above' | 'below' | 'left' | 'right';
+
+type SkyAffixPosition = 'absolute' | 'fixed';
+
+/**
+ * The vertical alignment of the affixed element to the base element.
+ */
+type SkyAffixVerticalAlignment = 'top' | 'middle' | 'bottom';
+
+interface SkyAffixConfig {
+    /**
+     * Which parent element is used by the auto-fit functionality.
+     */
+    autoFitContext?: SkyAffixAutoFitContext;
+    /**
+     * This optional offset is added to (or subtracted from) the [[SkyAffixAutoFitContext]] element's
+     * offset during an auto-fit placement calculation. This value is useful if you need to consider
+     * another `position: fixed` element on the page (such as a navbar) when the auto-fit
+     * functionality attempts to find the best possible placement.
+     * (In the case of a navbar, you would add a `top` value equal to the navbar's height in pixels.)
+     */
+    autoFitOverflowOffset?: SkyAffixOffset;
+    /**
+     * Whether the affix service tries to find the best placement for the affixed element
+     * if the element would be hidden otherwise. If this setting is disabled, the affix service
+     * forces the placement of the affixed element.
+     */
+    enableAutoFit?: boolean;
+    /**
+     * The horizontal alignment of the affixed element to the base element.
+     */
+    horizontalAlignment?: SkyAffixHorizontalAlignment;
+    /**
+     * Whether the affixed element remains affixed to the base element when the window is scrolled or resized.
+     */
+    isSticky?: boolean;
+    /**
+     * The placement of the affixed element around the base element.
+     */
+    placement?: SkyAffixPlacement;
+    /**
+     * The vertical alignment of the affixed element to the base element.
+     */
+    verticalAlignment?: SkyAffixVerticalAlignment;
+    /**
+     * The position of the element being affixed.
+     */
+    position?: SkyAffixPosition;
+}
+
+/**
+ * The arguments supplied to the affix offset change event listener.
+ */
+interface SkyAffixOffsetChange {
+    offset?: SkyAffixOffset;
+}
+
+interface SkyAffixPlacementChange {
+    /**
+     * The changed placement value.
+     */
+    placement: SkyAffixPlacement | null;
+}
+
+declare class SkyAffixer {
+    #private;
+    /**
+     * Fires when the affixed element's offset changes.
+     */
+    get offsetChange(): Observable<SkyAffixOffsetChange>;
+    /**
+     * Fires when the base element's nearest overflow parent is scrolling. This is useful if you need
+     * to perform an additional action during the scroll event but don't want to generate another
+     * event listener.
+     */
+    get overflowScroll(): Observable<void>;
+    /**
+     * Fires when the placement value changes. A `null` value indicates that a suitable
+     * placement could not be found.
+     */
+    get placementChange(): Observable<SkyAffixPlacementChange>;
+    constructor(affixedElement: HTMLElement, renderer: Renderer2, viewportRuler: ViewportRuler, zone: NgZone, layoutViewport: HTMLElement);
+    /**
+     * Affixes an element to a base element.
+     * @param baseElement The base element.
+     * @param config Configuration for the affix action.
+     */
+    affixTo(baseElement: HTMLElement, config?: SkyAffixConfig): void;
+    getConfig(): SkyAffixConfig;
+    /**
+     * Re-runs the affix calculation.
+     */
+    reaffix(): void;
+    /**
+     * Destroys the affixer.
+     */
+    destroy(): void;
+}
+
+declare class SkyAffixService implements OnDestroy {
+    #private;
+    ngOnDestroy(): void;
+    /**
+     * Creates an instance of [[SkyAffixer]].
+     * @param affixed The element to be affixed.
+     */
+    createAffixer(affixed: ElementRef): SkyAffixer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAffixService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyAffixService>;
+}
+
+/**
+ * Affixes the host element to a base element.
+ */
+declare class SkyAffixDirective implements OnInit, OnChanges, OnDestroy {
+    #private;
+    /**
+     * The base element to affix the host element.
+     */
+    skyAffixTo: HTMLElement | undefined;
+    /**
+     * Sets the `autoFitContext` property of [[SkyAffixConfig]].
+     */
+    affixAutoFitContext: SkyAffixAutoFitContext | undefined;
+    /**
+     * Sets the `autoFitOverflowOffset` property of [[SkyAffixConfig]].
+     */
+    affixAutoFitOverflowOffset: SkyAffixOffset | undefined;
+    /**
+     * Sets the `enableAutoFit` property of [[SkyAffixConfig]].
+     */
+    affixEnableAutoFit: boolean | undefined;
+    /**
+     * Sets the `horizontalAlignment` property of [[SkyAffixConfig]].
+     */
+    affixHorizontalAlignment: SkyAffixHorizontalAlignment | undefined;
+    /**
+     * Sets the `isSticky` property of [[SkyAffixConfig]].
+     */
+    affixIsSticky: boolean | undefined;
+    /**
+     * Sets the `placement` property of [[SkyAffixConfig]].
+     */
+    affixPlacement: SkyAffixPlacement | undefined;
+    /**
+     * Sets the `position` property of [[SkyAffixConfig]].
+     */
+    affixPosition: SkyAffixPosition | undefined;
+    /**
+     * Sets the `verticalAlignment` property of [[SkyAffixConfig]].
+     */
+    affixVerticalAlignment: SkyAffixVerticalAlignment | undefined;
+    /**
+     * Fires when the affixed element's offset changes.
+     */
+    affixOffsetChange: EventEmitter<SkyAffixOffsetChange>;
+    /**
+     * Fires when the affixed element's overflow container is scrolled.
+     */
+    affixOverflowScroll: EventEmitter<void>;
+    /**
+     * Fires when the placement value changes.
+     */
+    affixPlacementChange: EventEmitter<SkyAffixPlacementChange>;
+    constructor(elementRef: ElementRef, affixService: SkyAffixService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyAffixDirective, "[skyAffixTo]", never, { "skyAffixTo": { "alias": "skyAffixTo"; "required": false; }; "affixAutoFitContext": { "alias": "affixAutoFitContext"; "required": false; }; "affixAutoFitOverflowOffset": { "alias": "affixAutoFitOverflowOffset"; "required": false; }; "affixEnableAutoFit": { "alias": "affixEnableAutoFit"; "required": false; }; "affixHorizontalAlignment": { "alias": "affixHorizontalAlignment"; "required": false; }; "affixIsSticky": { "alias": "affixIsSticky"; "required": false; }; "affixPlacement": { "alias": "affixPlacement"; "required": false; }; "affixPosition": { "alias": "affixPosition"; "required": false; }; "affixVerticalAlignment": { "alias": "affixVerticalAlignment"; "required": false; }; }, { "affixOffsetChange": "affixOffsetChange"; "affixOverflowScroll": "affixOverflowScroll"; "affixPlacementChange": "affixPlacementChange"; }, never, never, false, never>;
+}
+
+declare class SkyAffixModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAffixModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyAffixModule, [typeof SkyAffixDirective], [typeof i2.CommonModule], [typeof SkyAffixDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyAffixModule>;
+}
+
+/**
+ * Text or an element that describes the content a consumer renders in a component.
+ *
+ * @internal
+ */
+interface SkyContentInfoDescriptor {
+    /**
+     * A descriptor of type `text` is an already localized string that describes a parent's content, i.e. constituent.
+     * A descriptor of type `elementId` is an HTML Element ID of an element that describes a parent's content, i.e. the ID to a box header.
+     */
+    type: 'text' | 'elementId';
+    /**
+     * A value of the given type.
+     */
+    value: string;
+}
+
+/**
+ * Information about the content a consumer is rendering within a component.
+ *
+ * @internal
+ */
+interface SkyContentInfo {
+    /**
+     * Information that describes the content within a parent component a consumer has rendered, i.e. "constituents".
+     * Provided as localized text or an element ID pointing to text that is the descriptor.
+     */
+    descriptor?: SkyContentInfoDescriptor;
+}
+
+/**
+ * @internal
+ * An API to provide information about a parent component's content to child components.
+ * For example, toolbar can use this to provide its child components with a list
+ * descriptor they can use to construct aria labels, or tree view can provide the node
+ * name to its context menus.
+ */
+declare class SkyContentInfoProvider {
+    #private;
+    patchInfo(value: SkyContentInfo): void;
+    getInfo(): Observable<SkyContentInfo>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyContentInfoProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyContentInfoProvider>;
+}
+
+/**
+ * @internal
+ * An API to provide default Angular component input values to child components.
+ */
+declare class SkyDefaultInputProvider {
+    #private;
+    setValue<T>(componentName: string, inputName: string, value: T): void;
+    getValue<T>(componentName: string, inputName: string): Observable<T> | undefined;
+}
+
+/**
+ * Configuration to be used by the docking action.
+ */
+interface SkyDockItemConfig {
+    /**
+     * The stack order of the item. The higher the number, the higher
+     * the item will be placed in the dock. By default, new items will be placed at
+     * the top of the stack.
+     */
+    stackOrder?: number;
+}
+
+interface SkyDockInsertComponentConfig extends SkyDockItemConfig {
+    /**
+     * Static providers to inject into the item's component.
+     */
+    providers?: StaticProvider[];
+}
+
+/**
+ * Represents a single item added to the dock.
+ */
+declare class SkyDockItem<T> {
+    #private;
+    readonly componentInstance: T;
+    readonly stackOrder: number;
+    /**
+     * An event that emits when the item is removed from the dock.
+     */
+    get destroyed(): Observable<void>;
+    /**
+     * @param componentInstance The item's component instance.
+     * @param stackOrder The assigned stack order of the docked item.
+     */
+    constructor(componentInstance: T, stackOrder: number);
+    /**
+     * Removes the item from the dock.
+     */
+    destroy(): void;
+}
+
+/**
+ * The location on the page where the dock component should be rendered.
+ */
+declare enum SkyDockLocation {
+    /**
+     * Renders the dock component before a given element.
+     */
+    BeforeElement = 0,
+    /**
+     * Renders the dock component as the last element inside the BODY element.
+     */
+    BodyBottom = 1,
+    /**
+     * Renders the dock component as the last element inside a given element.
+     */
+    ElementBottom = 2
+}
+
+/**
+ * Options for adding a dock component to the page.
+ */
+interface SkyDockOptions {
+    /**
+     * The location on the page where the dock component should be rendered.
+     */
+    location?: SkyDockLocation;
+    /**
+     * The reference element used when using the `BeforeElement` or `ElementBottom` locations.
+     */
+    referenceEl?: HTMLElement;
+    /**
+     * The z-index for the dock element
+     */
+    zIndex?: number;
+}
+
+/**
+ * @deprecated The `SkyDockModule` is no longer needed and can be removed from your application.
+ * @internal
+ */
+declare class SkyDockModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyDockModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyDockModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyDockModule>;
+}
+
+/**
+ * This service docks components to specific areas on the page.
+ */
+declare class SkyDockService {
+    #private;
+    private static dockRef;
+    private static _items;
+    /**
+     * Returns all docked items.
+     */
+    get items(): SkyDockItem<any>[];
+    /**
+     * Docks a component to the bottom of the page.
+     * @param component The component to dock.
+     * @param config Options that affect the docking action.
+     */
+    insertComponent<T>(component: Type<T>, config?: SkyDockInsertComponentConfig): SkyDockItem<T>;
+    /**
+     * Sets options for the positioning and styling of the dock component. Since the dock service is a
+     * singleton instance, these options will be applied to all components inserted into the dock. In
+     * order to create a separate dock with different options, consumers should provide a different
+     * instance of the dock service.
+     * @param options The options for positioning and styling
+     */
+    setDockOptions(options: SkyDockOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyDockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyDockService>;
+}
+
+/**
+ * The location on the page where the dynamic component should be rendered.
+ */
+declare enum SkyDynamicComponentLocation {
+    /**
+     * Renders the dynamic component before a given element.
+     */
+    BeforeElement = 0,
+    /**
+     * Renders the dynamic component as the last element inside the BODY element.
+     */
+    BodyBottom = 1,
+    /**
+     * Renders the dynamic component as the first element inside the BODY element.
+     */
+    BodyTop = 2,
+    /**
+     * Renders the dynamic component as the last element inside a given element.
+     */
+    ElementBottom = 3,
+    /**
+     * Renders the dynamic component as the first element inside a given element.
+     */
+    ElementTop = 4
+}
+
+/**
+ * Options for adding a dynamic component to the page.
+ */
+interface SkyDynamicComponentOptions {
+    /**
+     * The location on the page where the dynamic component should be rendered.
+     */
+    location?: SkyDynamicComponentLocation;
+    /**
+     * Providers to inject into the new component.
+     */
+    providers?: StaticProvider[];
+    /**
+     * The reference element used when using the `ElementTop` or `ElementBottom` locations.
+     */
+    referenceEl?: HTMLElement;
+    /**
+     * The view container reference where the new component should be appended.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * The environment injector to use instead of the dynamic component service's injector.
+     */
+    environmentInjector?: EnvironmentInjector;
+    /**
+     * A class to add to the created component
+     */
+    className?: string;
+}
+
+/**
+ * Provides services required to create dynamic components on the page.
+ * @deprecated The `SkyDynamicComponentService` no longer needs the `SkyDynamicComponentModule`.
+ * The `SkyDynamicComponentModule` can be removed from your project.
+ */
+declare class SkyDynamicComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyDynamicComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyDynamicComponentModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyDynamicComponentModule>;
+}
+
+/**
+ * The application window reference service references the global window variable.
+ * After users inject SkyAppWindowRef into a component, they can use the service to interact with
+ * window properties and event handlers by referencing its nativeWindow property.
+ */
+declare class SkyAppWindowRef {
+    /**
+     * The global `window` variable.
+     */
+    get nativeWindow(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAppWindowRef, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyAppWindowRef>;
+}
+
+/**
+ * Angular service for creating and rendering a dynamic component.
+ * @internal
+ */
+declare class SkyDynamicComponentService {
+    #private;
+    constructor(applicationRef: ApplicationRef, windowRef: SkyAppWindowRef, rendererFactory: RendererFactory2);
+    /**
+     * Creates an instance of the specified component and adds it to the specified location
+     * on the page.
+     */
+    createComponent<T>(componentType: Type<T>, options?: SkyDynamicComponentOptions): ComponentRef<T>;
+    /**
+     * Removes a component ref from the page
+     * @param componentRef Component ref for the component being removed
+     */
+    removeComponent<T>(componentRef: ComponentRef<T> | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyDynamicComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyDynamicComponentService>;
+}
+/**
+ * Angular service for creating and rendering a dynamic component.
+ * @internal
+ * @deprecated Use `SkyDynamicComponentService` to create a standalone component instead.
+ */
+declare class SkyDynamicComponentLegacyService extends SkyDynamicComponentService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyDynamicComponentLegacyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyDynamicComponentLegacyService>;
+}
+
+/**
+ * Wraps the FileReader API so it can be mocked in tests.
+ * @internal
+ */
+declare class SkyFileReaderService {
+    readAsDataURL(file: File): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyFileReaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyFileReaderService>;
+}
+
+declare class SkyAppFormat {
+    formatText(format: string, ...args: any[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAppFormat, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyAppFormat>;
+}
+
+/**
+ * Options to apply to all components that invoke global help.
+ */
+interface SkyHelpGlobalOptions {
+    /**
+     * The ID of the element that is displayed when the invoking component is clicked.
+     */
+    ariaControls?: string;
+    /**
+     * The type of popup triggered by the invoking component.
+     */
+    ariaHaspopup?: 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
+}
+
+/**
+ * Injection token for specifying and retrieving global help options.
+ */
+declare const SKY_HELP_GLOBAL_OPTIONS: InjectionToken<SkyHelpGlobalOptions>;
+
+/**
+ * Options for displaying a globally accessible help dialog.
+ */
+interface SkyHelpOpenArgs {
+    /**
+     * A unique key that identifies the help content to display.
+     * */
+    helpKey: string;
+}
+
+/**
+ *  Options for updating a globally accessible help dialog.
+ */
+interface SkyHelpUpdateArgs {
+    /**
+     * A unique key that identifies the current help content to display. If set to `undefined`, the page's default help content will be displayed.
+     */
+    helpKey?: string;
+    /**
+     * A unique key that identifies the page's default help content to display. Set this property to `undefined` to unset the current page default help key.
+     * */
+    pageDefaultHelpKey?: string;
+}
+
+/**
+ * Provides methods for opening and updating a globally accessible help dialog.
+ */
+declare abstract class SkyHelpService {
+    /**
+     * Emits when the help widget ready state changes.
+     */
+    get widgetReadyStateChange(): Observable<boolean>;
+    /**
+     * Opens a globally accessible help dialog.
+     * @param args The options for opening the help dialog.
+     */
+    abstract openHelp(args?: SkyHelpOpenArgs): void;
+    /**
+     * Updates a globally accessible help dialog.
+     * @param args The options for updating the help dialog.
+     */
+    abstract updateHelp(args: SkyHelpUpdateArgs): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyHelpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyHelpService>;
+}
+
+/**
+ * Generates unique IDs to be used with HTML elements.
+ */
+declare class SkyIdService {
+    generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyIdService>;
+}
+
+/**
+ * Sets the element's `id` attribute to a unique ID. To reference this unique ID on other elements,
+ * such as in a `label` element's `for` attribute, assign this directive to a template reference
+ * variable, then use its `id` property.
+ */
+declare class SkyIdDirective {
+    #private;
+    get id(): string;
+    constructor(elRef: ElementRef, renderer: Renderer2, idSvc: SkyIdService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyIdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyIdDirective, "[skyId]", ["skyId"], {}, {}, never, never, false, never>;
+}
+
+declare class SkyIdModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyIdModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyIdModule, [typeof SkyIdDirective], never, [typeof SkyIdDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyIdModule>;
+}
+
+interface SkyLayoutHostForChildArgs {
+    layout: string;
+}
+
+/**
+ * @internal
+ */
+declare class SkyLayoutHostDirective<T = 'none' | 'fit'> {
+    #private;
+    readonly layout: i0.InputSignal<T | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyLayoutHostDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyLayoutHostDirective<any>, "[skyLayoutHost]", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @internal
+ */
+declare class SkyLayoutHostService {
+    #private;
+    get hostLayoutForChild(): Observable<SkyLayoutHostForChildArgs>;
+    setHostLayoutForChild(layout: SkyLayoutHostForChildArgs): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyLayoutHostService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyLayoutHostService>;
+}
+
+/**
+ * Possible politeness levels for messages announced via the `SkyLiveAnnouncerService`.
+ * @internal
+ */
+type SkyLiveAnnouncerPoliteness = 'off' | 'polite' | 'assertive';
+
+/**
+ * Options used when announcing messages to screen readers via the `SkyLiveAnnouncerService`
+ * @internal
+ */
+interface SkyLiveAnnouncerArgs {
+    politeness?: SkyLiveAnnouncerPoliteness;
+    /**
+     * Sets how long the live announcer text persists in DOM.
+     */
+    duration?: number;
+}
+
+/**
+ * Allows for announcing messages to screen reader users through the use of a common `aria-live` element.
+ * @internal
+ */
+declare class SkyLiveAnnouncerService implements OnDestroy {
+    #private;
+    announcerElementChanged: ReplaySubject<HTMLElement | undefined>;
+    constructor();
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param args Options for the announcement of the message.
+     */
+    announce(message: string, args?: SkyLiveAnnouncerArgs): void;
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear(): void;
+    /**
+     * @internal
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyLiveAnnouncerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyLiveAnnouncerService>;
+}
+
+/**
+ * @deprecated The `SkyLogService` no longer needs the `SkyLogModule`.
+ * The `SkyLogModule` can be removed from your project.
+ */
+declare class SkyLogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyLogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyLogModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyLogModule>;
+}
+
+/**
+ * @internal
+ */
+declare enum SkyLogLevel {
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}
+
+/**
+ * @internal
+ * Arguments used when logging that a class, property, function, etc. is deprecated.
+ */
+interface SkyLogDeprecatedArgs {
+    /**
+     * The major version which deprecated the feature.
+     */
+    deprecationMajorVersion?: number;
+    /**
+     * The log level for the console logging. The `SkyLogService` will assume `SkyLogLevel.Warn` if this is not provided.
+     */
+    logLevel?: SkyLogLevel;
+    /**
+     * A URL which gives more information about the deprecation or the replacement recommendation.
+     */
+    moreInfoUrl?: string;
+    /**
+     * The major version which will remove the deprecated feature.
+     */
+    removalMajorVersion?: number;
+    /**
+     * The recommendation for how to replace the deprecated feature.
+     */
+    replacementRecommendation?: string;
+}
+
+/**
+ * Logs information to the console based on the application's log level as
+ * provided by the `SKY_LOG_LEVEL` injection token. If no token is provided,
+ * only `error` logs will be shown.
+ * @internal
+ */
+declare class SkyLogService {
+    #private;
+    constructor(formatter: SkyAppFormat, applicationLogLevel?: SkyLogLevel);
+    /**
+     * Clears previously-logged messages. Primarily used for unit
+     * testing this service.
+     */
+    static clearPreviousLogs(): void;
+    /**
+     * Logs a deprecation warning for a class, property, function, etc. This will
+     * be logged as a console warning unless a different log level is given in the
+     * `args` parameter.
+     * @param name The name of the deprecated class, property, function, etc.
+     * @param args Information about the deprecation and replacement recommendations.
+     */
+    deprecated(name: string, args?: SkyLogDeprecatedArgs): void;
+    /**
+     * Logs a console error if the application's log level is `SkyLogLevel.Error`.
+     * @param message The error message
+     * @param params Optional parameters for the error message.
+     */
+    error(message: string, params?: unknown[]): void;
+    /**
+     * Logs console information if the application's log level is `SkyLogLevel.Info` or above.
+     * @param message The informational message
+     * @param params Optional parameters for the informational message.
+     */
+    info(message: string, params?: unknown[]): void;
+    /**
+     * Logs a console warning if the application's log level is `SkyLogLevel.Warn` or above.
+     * @param message The warning message
+     * @param params Optional parameters for the warning message.
+     */
+    warn(message: string, params?: unknown[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyLogService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyLogService>;
+}
+
+/**
+ * @internal
+ */
+declare const SKY_LOG_LEVEL: InjectionToken<SkyLogLevel>;
+
+/**
+ * @internal
+ */
+interface SkyBreakpointObserver {
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    destroy(): void;
+}
+
+/**
+ * Used to override a breakpoint observer for specific execution contexts.
+ * @internal
+ */
+declare const SKY_BREAKPOINT_OBSERVER: InjectionToken<SkyBreakpointObserver>;
+
+/**
+ * Emits when the width of the host container changes.
+ * @internal
+ */
+declare class SkyContainerBreakpointObserver implements OnDestroy, SkyBreakpointObserver {
+    #private;
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    constructor();
+    ngOnDestroy(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyContainerBreakpointObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyContainerBreakpointObserver>;
+}
+
+/**
+ * Emits when the viewport width changes.
+ * @internal
+ */
+declare class SkyMediaBreakpointObserver implements OnDestroy, SkyBreakpointObserver {
+    #private;
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    constructor();
+    ngOnDestroy(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyMediaBreakpointObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyMediaBreakpointObserver>;
+}
+
+/**
+ * Overrides the default media breakpoint observer with the given observer.
+ * @internal
+ */
+declare function provideSkyBreakpointObserver(observer: Type<SkyBreakpointObserver>): Provider[];
+
+/**
+ * Overrides the `SkyMediaQueryService` to emit breakpoint changes when the host
+ * container is resized. This directive also adds SKY UX CSS classes to the
+ * host element to allow for responsive styles.
+ */
+declare class SkyResponsiveHostDirective {
+    #private;
+    /**
+     * Emits when the breakpoint changes.
+     */
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    /**
+     * The injector of the responsive host. Useful when displaying child components
+     * via `ngTemplateOutlet`.
+     * @example```
+     * <my-container #responsiveHost="skyResponsiveHost">
+     *   <ng-container
+     *     [ngTemplateOutlet]="myTemplate"
+     *     [ngTemplateOutletInjector]="responsiveHost.injector"
+     *   />
+     * </my-container>
+     * ```
+     */
+    get injector(): Injector;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyResponsiveHostDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyResponsiveHostDirective, "[skyResponsiveHost]", ["skyResponsiveHost"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The function that is called when the breakpoints change. It is called
+ * with a `SkyMediaBreakpoints` argument, which is an enum that represents the new breakpoint.
+ * @deprecated Subscribe to the `breakpointChange` observable instead.
+ */
+type SkyMediaQueryListener = (args: SkyMediaBreakpoints) => void;
+
+/**
+ * @deprecated The `SkyMediaQueryService` no longer needs the `SkyMediaQueryModule`.
+ * The `SkyMediaQueryModule` can be removed from your project.
+ */
+declare class SkyMediaQueryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyMediaQueryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyMediaQueryModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyMediaQueryModule>;
+}
+
+/**
+ * Utility used to subscribe to viewport and container breakpoint changes.
+ */
+declare class SkyMediaQueryService implements OnDestroy {
+    #private;
+    /**
+     * Emits when the breakpoint changes.
+     */
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    /**
+     * The size for the `xs` breakpoint.
+     * @default "(max-width: 767px)"
+     */
+    static xs: string;
+    /**
+     * The size for the `sm` breakpoint.
+     * @default "(min-width: 768px) and (max-width: 991px)"
+     */
+    static sm: string;
+    /**
+     * The size for the `md` breakpoint.
+     * @default "(min-width: 992px) and (max-width: 1199px)"
+     */
+    static md: string;
+    /**
+     * The size for the `lg` breakpoint.
+     * @default "(min-width: 1200px)"
+     */
+    static lg: string;
+    /**
+     * Returns the current breakpoint.
+     * @deprecated Subscribe to the `breakpointChange` observable instead.
+     */
+    get current(): SkyMediaBreakpoints;
+    constructor(_zone?: NgZone);
+    ngOnDestroy(): void;
+    /**
+     * @internal
+     */
+    destroy(): void;
+    /**
+     * Subscribes to screen size changes.
+     * @param listener Specifies a function that is called when breakpoints change.
+     * @deprecated Subscribe to the `breakpointChange` observable instead.
+     */
+    subscribe(listener: SkyMediaQueryListener): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyMediaQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyMediaQueryService>;
+}
+
+/**
+ * @internal
+ */
+declare class SkyMutationObserverService {
+    create(callback: MutationCallback): MutationObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyMutationObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyMutationObserverService>;
+}
+
+/**
+ * @internal
+ */
+interface SkyNumericSymbol {
+    value: number;
+    label: string;
+}
+
+/**
+ * Provides arguments for the number to format.
+ */
+interface SkyNumericOptions {
+    /**
+     * Specifies the maximum number of digits after the decimal separator.
+     */
+    digits?: number;
+    /**
+     * Specifies how to format the number. Options are `currency` or `number`.
+     */
+    format?: string;
+    /**
+     * Specifies the format of the currency.
+     */
+    currencySign?: 'accounting' | 'standard';
+    /**
+     * Specifies the display of the currency. Defaults to 'symbol'.
+     */
+    currencyDisplay?: 'code' | 'symbol' | 'narrowSymbol' | 'name';
+    /**
+     * Specifies the ISO4217 currency code to use for currency formatting.
+     */
+    iso?: string;
+    /**
+     * Specifies the locale code to use when formatting.
+     */
+    locale?: string;
+    /**
+     * Specifies the minimum number of digits after the decimal separator. This property only applies
+     * when the `truncate` property is set to `false`. If `digits` specifies a maximum number of
+     * digits, then `minDigits` must be less than that value.
+     */
+    minDigits?: number;
+    /**
+     * Indicates whether to shorten numbers to rounded numbers and abbreviation characters
+     * such as K for thousands, M for millions, B for billions, and T for trillions.
+     */
+    truncate?: boolean;
+    /**
+     * Specifies the minimum value at which numbers are shortened to rounded numbers and abbreviation characters. Values less than `1000` are not truncated.
+     */
+    truncateAfter?: number;
+}
+/**
+ * Provides arguments for the number to format.
+ * @deprecated Use the `SkyNumericOptions` interface instead.
+ * @internal
+ */
+declare class NumericOptions implements SkyNumericOptions {
+    digits?: number;
+    format?: string;
+    currencySign?: 'accounting' | 'standard';
+    currencyDisplay?: 'code' | 'symbol' | 'narrowSymbol' | 'name';
+    iso?: string;
+    locale?: string;
+    minDigits?: number;
+    truncate?: boolean;
+    truncateAfter?: number;
+    constructor();
+}
+
+declare class SkyNumericService {
+    #private;
+    /**
+     * The browser's current locale.
+     * @internal
+     */
+    currentLocale: string;
+    /**
+     * @internal
+     */
+    shortSymbol: string;
+    constructor(resourcesSvc: SkyLibResourcesService);
+    /**
+     * Formats a number based on the provided options.
+     * @param value The number to format.
+     * @param options Format options.
+     */
+    formatNumber(value: number | undefined | null, options: SkyNumericOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyNumericService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyNumericService>;
+}
+
+/**
+ * Shortens numbers to rounded numbers and abbreviation characters such as K for thousands,
+ * M for millions, B for billions, and T for trillions. The pipe also formats for currency.
+ * Be sure you have a space after the two curly brackets opening the pipe and
+ * a space before the two curly brackets closing the pipe or it will not work.
+ */
+declare class SkyNumericPipe implements PipeTransform, OnDestroy {
+    #private;
+    constructor(localeProvider: SkyAppLocaleProvider, numericSvc: SkyNumericService, changeDetector: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    /**
+     * Formats a number based on the provided options.
+     */
+    transform(value: number | undefined | null, config?: SkyNumericOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyNumericPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SkyNumericPipe, "skyNumeric", false>;
+}
+
+/**
+ * Import into any component library module that needs to use resource strings.
+ */
+declare class SkyCoreResourcesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyCoreResourcesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyCoreResourcesModule, never, never, [typeof i1.SkyI18nModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyCoreResourcesModule>;
+}
+
+declare class SkyNumericModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyNumericModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyNumericModule, [typeof SkyNumericPipe], [typeof SkyCoreResourcesModule], [typeof SkyNumericPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyNumericModule>;
+}
+
+type SkyOverlayPosition = 'absolute' | 'fixed';
+
+interface SkyOverlayConfig {
+    /**
+     * Whether the overlay closes after a navigation change.
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Whether the overlay closes when a user clicks outside the overlay's content.
+     */
+    enableClose?: boolean;
+    /**
+     * Whether mouse interactions are allowed below the backdrop.
+     */
+    enablePointerEvents?: boolean;
+    /**
+     * Whether window scrolling is enabled when the overlay is opened.
+     */
+    enableScroll?: boolean;
+    /**
+     * The environment injector for the overlay component.
+     */
+    environmentInjector?: EnvironmentInjector;
+    /**
+     * Whether the overlay's backdrop is visible.
+     */
+    showBackdrop?: boolean;
+    /**
+     * Extra CSS classes to add to the overlay's wrapper element.
+     */
+    wrapperClass?: string;
+    /**
+     * The position of the overlay instance.
+     */
+    position?: SkyOverlayPosition;
+    /**
+     * Hides the overlay's siblings from screen readers so users can't interact
+     * with content behind the overlay with assistive technology.
+     */
+    hideOthersFromScreenReaders?: boolean;
+}
+
+/**
+ * @internal
+ */
+declare class SkyOverlayComponent implements OnInit, OnDestroy {
+    #private;
+    wrapperClass: string;
+    get backdropClick(): Observable<void>;
+    get closed(): Observable<void>;
+    enablePointerEvents: boolean;
+    id: string;
+    showBackdrop: boolean;
+    zIndex: string;
+    protected clipPath$: ReplaySubject<string | undefined>;
+    protected position: SkyOverlayPosition;
+    overlayContentRef: ElementRef | undefined;
+    overlayRef: ElementRef | undefined;
+    targetRef: ViewContainerRef | undefined;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    attachComponent<C>(component: Type<C>, providers?: StaticProvider[]): ComponentRef<C>;
+    attachTemplate<T>(templateRef: TemplateRef<T>, context: T): EmbeddedViewRef<T>;
+    updateClipPath(clipPath: string | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyOverlayComponent, "sky-overlay", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a new overlay instance. It is used to manage the "closed" state of the overlay,
+ * and access any public members on the appended content component instance.
+ */
+declare class SkyOverlayInstance {
+    #private;
+    /**
+     * The configuration for the overlay.
+     */
+    readonly config: SkyOverlayConfig;
+    readonly componentRef: ComponentRef<SkyOverlayComponent>;
+    /**
+     * Emits when the overlay is clicked (but not its content).
+     */
+    get backdropClick(): Observable<void>;
+    /**
+     * Emits after the overlay is closed.
+     */
+    get closed(): Observable<void>;
+    id: string;
+    constructor(
+    /**
+     * The configuration for the overlay.
+     */
+    config: SkyOverlayConfig, componentRef: ComponentRef<SkyOverlayComponent>);
+    /**
+     * Creates and attaches a component to the overlay.
+     * @param component The component to attach.
+     * @param providers Custom providers to apply to the component.
+     */
+    attachComponent<C>(component: Type<C>, providers?: StaticProvider[]): C;
+    /**
+     * Attaches a `TemplateRef` to the overlay.
+     * @param templateRef The `TemplateRef` to attach.
+     * @param context The context to provide to the template.
+     */
+    attachTemplate<T>(templateRef: TemplateRef<T>, context?: T): void;
+}
+
+/**
+ * @deprecated The `SkyOverlayModule` is no longer needed and can be removed from your application.
+ * @internal
+ */
+declare class SkyOverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyOverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyOverlayModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyOverlayModule>;
+}
+
+/**
+ * This service is used to create new overlays.
+ * @internal
+ */
+declare class SkyOverlayService {
+    #private;
+    private static overlays;
+    constructor(dynamicComponentSvc: SkyDynamicComponentService);
+    /**
+     * Creates an empty overlay. Use the returned `SkyOverlayInstance` to append content.
+     * @param config Configuration for the overlay.
+     */
+    create(config?: SkyOverlayConfig): SkyOverlayInstance;
+    /**
+     * Closes (and destroys) an overlay instance.
+     * @param instance The instance to close.
+     */
+    close(instance: SkyOverlayInstance): void;
+    /**
+     * Closes all overlay instances.
+     */
+    closeAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyOverlayService>;
+}
+/**
+ * This service is used to create new overlays.
+ * @internal
+ * @deprecated Use `SkyOverlayService` to open a standalone component instead.
+ */
+declare class SkyOverlayLegacyService extends SkyOverlayService {
+    constructor(dynamicComponentSvc: SkyDynamicComponentLegacyService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyOverlayLegacyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyOverlayLegacyService>;
+}
+
+declare class SkyPercentPipe implements OnDestroy, PipeTransform {
+    #private;
+    get defaultLocale(): string;
+    constructor(localeProvider: SkyAppLocaleProvider);
+    ngOnDestroy(): void;
+    transform(value: string, format?: string, locale?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyPercentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SkyPercentPipe, "skyPercent", false>;
+}
+
+declare class SkyPercentPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyPercentPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyPercentPipeModule, [typeof SkyPercentPipe], [typeof SkyCoreResourcesModule], [typeof SkyPercentPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyPercentPipeModule>;
+}
+
+/**
+ * Acts like `SkyMediaQueryService` for a container element, emitting the same responsive breakpoints.
+ * @deprecated Use the `SkyResponsiveHostDirective` instead.
+ */
+declare class SkyResizeObserverMediaQueryService extends SkyMediaQueryService implements OnDestroy {
+    #private;
+    /**
+     * Emits when the breakpoint changes.
+     */
+    get breakpointChange(): Observable<SkyBreakpoint>;
+    /**
+     * Returns the current breakpoint.
+     * @deprecated Subscribe to the `breakpointChange` observable instead.
+     */
+    get current(): SkyMediaBreakpoints;
+    ngOnDestroy(): void;
+    /**
+     * @internal
+     */
+    destroy(): void;
+    /**
+     * Sets the container element to watch. The `SkyResizeObserverMediaQueryService` will only observe one element at a
+     * time. Any previous subscriptions will be unsubscribed when a new element is observed.
+     */
+    observe(element: ElementRef, options?: {
+        updateResponsiveClasses?: boolean;
+    }): SkyResizeObserverMediaQueryService;
+    /**
+     * Stop watching the container element and remove any added classes.
+     */
+    unobserve(): void;
+    /**
+     * Subscribes to element size changes that cross breakpoints.
+     */
+    subscribe(listener: SkyMediaQueryListener): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyResizeObserverMediaQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyResizeObserverMediaQueryService>;
+}
+
+/**
+ * Service to create rxjs observables for changes to the content box dimensions of elements.
+ */
+declare class SkyResizeObserverService implements OnDestroy {
+    #private;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Create rxjs observable to get size changes for an element ref.
+     */
+    observe(element: ElementRef): Observable<ResizeObserverEntry>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyResizeObserverService>;
+}
+
+/**
+ * Adds the element to a screen reader only section of the body.
+ * This prevents components' DOM from including text only intended for screen readers.
+ *
+ * @internal
+ */
+declare class SkyScreenReaderLabelDirective implements OnDestroy {
+    #private;
+    ngOnDestroy(): void;
+    /**
+     * Indicates if the label should be created in the DOM.
+     * @default false
+     */
+    set createLabel(value: boolean | undefined);
+    get createLabel(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyScreenReaderLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyScreenReaderLabelDirective, "[skyScreenReaderLabel]", never, { "createLabel": { "alias": "createLabel"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @internal
+ */
+interface SkyScrollShadowEventArgs {
+    bottomShadow: string;
+    topShadow: string;
+}
+
+/**
+ * Raises an event when the box shadow for a component's header or footer should be adjusted
+ * based on the scroll position of the host element.
+ * @internal
+ */
+declare class SkyScrollShadowDirective implements OnDestroy {
+    #private;
+    set skyScrollShadowEnabled(value: boolean);
+    get skyScrollShadowEnabled(): boolean;
+    skyScrollShadow: EventEmitter<SkyScrollShadowEventArgs>;
+    windowResize(): void;
+    scroll(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyScrollShadowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyScrollShadowDirective, "[skyScrollShadow]", never, { "skyScrollShadowEnabled": { "alias": "skyScrollShadowEnabled"; "required": false; }; }, { "skyScrollShadow": "skyScrollShadow"; }, never, never, true, never>;
+}
+
+declare class SkyScrollableHostService {
+    #private;
+    constructor(mutationObserverSvc: SkyMutationObserverService, windowRef: SkyAppWindowRef, resizeObserverSvc?: SkyResizeObserverService, zone?: NgZone);
+    /**
+     * Returns the given element's current scrollable host
+     * @param elementRef The element whose scrollable host is being requested
+     * @returns The current scrollable host
+     */
+    getScrollableHost(elementRef: ElementRef): HTMLElement | Window;
+    /**
+     * Returns an observable which emits the given element's current scrollable host
+     * @param elementRef The element whose scrollable host is being requested
+     * @returns An observable which emits the current scrollable host element.
+     * @internal
+     */
+    watchScrollableHost(elementRef: ElementRef): Observable<HTMLElement | Window>;
+    /**
+     * Returns an observable which emits whenever the element's scrollable host emits a scroll event. The observable will always emit the scroll events from the elements current scrollable host and will update based on any scrollable host changes. The observable will also emit once whenever the scrollable host changes.
+     * @param elementRef The element whose scrollable host scroll events are being requested
+     * @returns An observable which emits when the elements scrollable host is scrolled or is changed
+     */
+    watchScrollableHostScrollEvents(elementRef: ElementRef): Observable<void>;
+    watchScrollableHostClipPathChanges(elementRef: ElementRef, additionalContainers?: Observable<ElementRef[]>): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyScrollableHostService, [null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyScrollableHostService>;
+}
+
+/**
+ * @internal
+ */
+interface SkyStackingContext {
+    zIndex: Observable<number>;
+}
+
+/**
+ * @internal
+ */
+declare const SKY_STACKING_CONTEXT: InjectionToken<SkyStackingContext>;
+
+interface SkyAppSetTitleArgs {
+    titleParts: string[];
+}
+
+/**
+ * Provides a method for setting a formatted title on the current window.
+ */
+declare class SkyAppTitleService {
+    #private;
+    constructor(title: Title);
+    /**
+     * Sets the title on the current window.
+     * @param args An array of title parts. The parts will be concatenated with a hyphen between
+     * each part.
+     */
+    setTitle(args: SkyAppSetTitleArgs | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyAppTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyAppTitleService>;
+}
+
+/**
+ * Trims whitespace in each text node that is a direct descendent of the current element.
+ */
+declare class SkyTrimDirective implements OnInit, OnDestroy {
+    #private;
+    constructor(elRef: ElementRef, mutationObs: SkyMutationObserverService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTrimDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyTrimDirective, "[skyTrim]", never, {}, {}, never, never, false, never>;
+}
+
+declare class SkyTrimModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTrimModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyTrimModule, [typeof SkyTrimDirective], never, [typeof SkyTrimDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyTrimModule>;
+}
+
+declare class SkyUIConfigService {
+    getConfig(key: string, defaultConfig?: any): Observable<any>;
+    setConfig(key: string, value: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyUIConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyUIConfigService>;
+}
+
+/**
+ * Options for creating a viewkeeper instance.
+ */
+interface SkyViewkeeperOptions {
+    /**
+     * The element that defines the bounds in which to keep the element in view. When the
+     * boundary element is scrolled out of view, the viewkeeper element will be scrolled
+     * out of view.
+     */
+    boundaryEl?: HTMLElement;
+    /**
+     * The element to keep in view.
+     */
+    el?: HTMLElement;
+    /**
+     * The scrollable parent where the viewkeeper resides. It should listen to and be
+     * positioned within the parent.
+     */
+    scrollableHost?: HTMLElement;
+    /**
+     * Sets the width of the viewkeeper element to the width of its
+     * host element. Otherwise, if the element does not have an explicit width specified,
+     * the element would collapse horizontally as a result of fixing the element to the top
+     * of the viewport.
+     */
+    setWidth?: boolean;
+    /**
+     * Reserved space in pixels above the viewkeeper element.
+     */
+    verticalOffset?: number;
+    /**
+     * The element under which the viewkeeper element should be fixed. Typically this is
+     * another viewkeeper element that is above the current viewkeeper element in the same
+     * boundary element.
+     */
+    verticalOffsetEl?: HTMLElement;
+    /**
+     * Reserved space in pixels at the top of the viewport.
+     */
+    viewportMarginTop?: number;
+    /**
+     * Custom CSS property for reserved space at the top of the viewport.
+     */
+    viewportMarginProperty?: `--${string}`;
+}
+
+declare class SkyViewkeeper {
+    #private;
+    constructor(options: SkyViewkeeperOptions);
+    syncElPosition(el: HTMLElement, boundaryEl: HTMLElement): void;
+    destroy(): void;
+}
+
+declare class SkyViewkeeperHostOptions implements SkyViewkeeperOptions {
+    boundaryEl?: HTMLElement;
+    el?: HTMLElement;
+    scrollableHost?: HTMLElement;
+    setWidth?: boolean;
+    verticalOffset?: number;
+    verticalOffsetEl?: HTMLElement;
+    viewportMarginTop?: number;
+    viewportMarginProperty?: `--${string}`;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyViewkeeperHostOptions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyViewkeeperHostOptions>;
+}
+
+/**
+ * Provides methods for creating and destroying viewkeeper instances.
+ */
+declare class SkyViewkeeperService {
+    #private;
+    constructor(hostOptions?: SkyViewkeeperHostOptions);
+    /**
+     *
+     * @param options Creates a viewkeeper instance, applying host options where applicable.
+     */
+    create(options: SkyViewkeeperOptions): SkyViewkeeper;
+    /**
+     * Destroys a viewkeeper instance.
+     * @param vk Viewkeeper instance to destroy.
+     */
+    destroy(vk: SkyViewkeeper): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyViewkeeperService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyViewkeeperService>;
+}
+
+declare class SkyViewkeeperDirective implements OnInit, OnDestroy, AfterViewInit {
+    #private;
+    set skyViewkeeper(value: string[] | undefined);
+    get skyViewkeeper(): string[] | undefined;
+    skyViewkeeperOmitShadow: string | undefined;
+    constructor(el: ElementRef, mutationObserverSvc: SkyMutationObserverService, viewkeeperSvc: SkyViewkeeperService, scrollableHostSvc?: SkyScrollableHostService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyViewkeeperDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkyViewkeeperDirective, "[skyViewkeeper]", never, { "skyViewkeeper": { "alias": "skyViewkeeper"; "required": false; }; "skyViewkeeperOmitShadow": { "alias": "skyViewkeeperOmitShadow"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SkyViewkeeperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyViewkeeperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyViewkeeperModule, [typeof SkyViewkeeperDirective], never, [typeof SkyViewkeeperDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyViewkeeperModule>;
+}
+
+/**
+ * Represents the version of a package.
+ * @internal
+ */
+declare class Version {
+    readonly full: string;
+    readonly major: string;
+    readonly minor: string;
+    readonly patch: string;
+    constructor(full: string);
+}
+/**
+ * Represents the version of @skyux/core.
+ */
+declare const VERSION: Version;
+
+export { NumericOptions, SKY_BREAKPOINTS, SKY_BREAKPOINT_OBSERVER, SKY_HELP_GLOBAL_OPTIONS, SKY_LOG_LEVEL, SKY_STACKING_CONTEXT, SkyAffixAutoFitContext, SkyAffixModule, SkyAffixService, SkyAffixer, SkyAppFormat, SkyAppTitleService, SkyAppWindowRef, SkyContainerBreakpointObserver, SkyContentInfoProvider, SkyCoreAdapterModule, SkyCoreAdapterService, SkyDefaultInputProvider, SkyDockItem, SkyDockLocation, SkyDockModule, SkyDockService, SkyDynamicComponentLegacyService, SkyDynamicComponentLocation, SkyDynamicComponentModule, SkyDynamicComponentService, SkyFileReaderService, SkyHelpService, SkyIdModule, SkyIdService, SkyLayoutHostDirective, SkyLayoutHostService, SkyLiveAnnouncerService, SkyLogLevel, SkyLogModule, SkyLogService, SkyMediaBreakpointObserver, SkyMediaBreakpoints, SkyMediaQueryModule, SkyMediaQueryService, SkyMutationObserverService, SkyNumericModule, SkyNumericPipe, SkyNumericService, SkyOverlayInstance, SkyOverlayLegacyService, SkyOverlayModule, SkyOverlayService, SkyPercentPipe, SkyPercentPipeModule, SkyResizeObserverMediaQueryService, SkyResizeObserverService, SkyResponsiveHostDirective, SkyScreenReaderLabelDirective, SkyScrollShadowDirective, SkyScrollableHostService, SkyTrimModule, SkyUIConfigService, SkyViewkeeper, SkyViewkeeperHostOptions, SkyViewkeeperModule, SkyViewkeeperService, VERSION, provideSkyBreakpointObserver, SkyAffixDirective as λ1, SkyIdDirective as λ2, SkyViewkeeperDirective as λ3, SkyTrimDirective as λ4 };
+export type { SkyAffixConfig, SkyAffixHorizontalAlignment, SkyAffixOffset, SkyAffixOffsetChange, SkyAffixPlacement, SkyAffixPlacementChange, SkyAffixPosition, SkyAffixVerticalAlignment, SkyAppSetTitleArgs, SkyBreakpoint, SkyBreakpointObserver, SkyContentInfo, SkyContentInfoDescriptor, SkyDockInsertComponentConfig, SkyDockItemConfig, SkyDockOptions, SkyDynamicComponentOptions, SkyFocusableChildrenOptions, SkyHelpGlobalOptions, SkyHelpOpenArgs, SkyHelpUpdateArgs, SkyLayoutHostForChildArgs, SkyLiveAnnouncerArgs, SkyLiveAnnouncerPoliteness, SkyMediaQueryListener, SkyNumericOptions, SkyNumericSymbol, SkyOverlayConfig, SkyOverlayPosition, SkyScrollShadowEventArgs, SkyStackingContext, SkyViewkeeperOptions };