@aquera/nile-elements 1.3.1 → 1.3.2-beta-1.1

package/README.md

@@ -79,10 +79,6 @@ To run a local development server that serves the basic demo located in `demo/in
 
 In this section, you can find the updates for each release of `nile-elements`. It's a good practice to maintain detailed release notes to help users and developers understand what changes have been made from one version to another and how these changes might affect their projects.
 
-#### Version 1.3.1
-- Nile Dropdown: Event binding issue fixed (UIF-1016)
-- Nile Lite Tooltip: UI Improvements for Lite Tooltip (UIF-1015)
-
 #### Version 1.3.0
 - Nile Inline Edit: autoClose feature added (UIF-1012)
 - Nile Calendar: Nile Calendar UI Improvements and Features Added (UIF-661)

package/dist/dist/types/src/index.d.ts

@@ -0,0 +1,107 @@
+export { NileButton } from './nile-button';
+export { NileHeading } from './nile-heading';
+export { NileIcon } from './nile-icon';
+export { NileInput } from './nile-input';
+export { NileMenu } from './nile-menu';
+export { NileBadge } from './nile-badge';
+export { NileDrawer } from './nile-drawer';
+export { NileCheckbox } from './nile-checkbox';
+export { NileRadio } from './nile-radio';
+export { NileRadioGroup } from './nile-radio-group';
+export { NilePopup } from './nile-popup';
+export { NileTooltip } from './nile-tooltip';
+export { NileSlideToggle } from './nile-slide-toggle';
+export { NileLoader } from './nile-loader';
+export { NileProgressBar } from './nile-progress-bar';
+export { NileSpinner } from './nile-spinner';
+export { NileSelect } from './nile-select';
+export { NileVirtualSelect } from './nile-virtual-select';
+export { NileOption } from './nile-option';
+export { NileTag } from './nile-tag';
+export { NileIconButton } from './nile-icon-button';
+export { NileMenuItem } from './nile-menu-item';
+export { NileDropdown } from './nile-dropdown';
+export { NileAutoComplete } from './nile-auto-complete';
+export { NileChip } from './nile-chip';
+export { NileTextarea } from './nile-textarea';
+export { NileDatePicker } from './nile-date-picker';
+export { NileErrorMessage } from './nile-error-message';
+export { NileFormErrorMessage } from './nile-form-error-message';
+export { NileFormHelpText } from './nile-form-help-text';
+export { NileCalendar } from './nile-calendar';
+export { NileLink } from './nile-link';
+export { NileButtonToggleGroup } from './nile-button-toggle-group';
+export { NileButtonToggle } from './nile-button-toggle';
+export { NileSwitcher } from './nile-switcher';
+export { NileContentEditor } from './nile-content-editor';
+export { NileDialog } from './nile-dialog';
+export { NileErrorNotification } from './nile-error-notification';
+export { NileTabGroup } from './nile-tab-group';
+export { NileTab } from './nile-tab';
+export { NileTabPanel } from './nile-tab-panel';
+export { NileCodeEditor } from './nile-code-editor';
+export { NileToast } from './nile-toast';
+export { NileBreadcrumb } from './nile-breadcrumb';
+export { NileBreadcrumbItem } from './nile-breadcrumb-item';
+export { NileFormGroup } from './nile-form-group';
+export { NileCard } from './nile-card';
+export { NilePopover } from './nile-popover';
+export { NileButtonFilter } from './nile-button-filter';
+export { NileCircularProgressbar } from './nile-circular-progressbar';
+export { NileTableCellItem } from './nile-table-cell-item';
+export { NileTableRow } from './nile-table-row';
+export { NileTableBody } from './nile-table-body';
+export { NileTableHeaderItem } from './nile-table-header-item';
+export { NileAvatar } from './nile-avatar';
+export { NilePageHeader } from './nile-page-header';
+export { NileEmptyState } from './nile-empty-state';
+export { NileHero } from './nile-hero';
+export { NileStepperItem } from './nile-stepper-item';
+export { NileStepper } from './nile-stepper';
+export { NileHeroHeader } from './nile-hero-header';
+export { NileVerticalStepperItem } from './nile-vertical-stepper-item';
+export { NileFormatDate } from './nile-format-date';
+export { NileSplitPanel } from './nile-split-panel';
+export { NileTree } from './nile-tree';
+export { NileTreeItem } from './nile-tree-item';
+export { NileListItem } from './nile-list-item';
+export { NileList } from './nile-list';
+export { NileAccordion } from './nile-accordion';
+export { NileDivider } from './nile-divider';
+export { NileTitle } from './nile-title';
+export { NileSectionMessage } from './nile-section-message';
+export { NileToolbar } from './nile-toolbar';
+export { NileInlineEdit } from './nile-inline-edit';
+export { NileTable } from './nile-table';
+export { NileFilterChip } from './nile-filter-chip';
+export { NilePagination } from './nile-pagination';
+export { NileSlider } from './nile-slider';
+export { NileFileUpload } from './nile-file-upload';
+export { NileFilePreview } from './nile-file-preview';
+export { NileOptionGroup } from './nile-option-group';
+export { NileGrid } from './nile-grid';
+export { NileGridBody } from './nile-grid/nile-grid-body';
+export { NileGridRow } from './nile-grid/nile-grid-row';
+export { NileGridHeadItem } from './nile-grid/nile-grid-head-item';
+export { NileGridCellItem } from './nile-grid/nile-grid-cell-item';
+export { NileGridHead } from './nile-grid/nile-grid-head';
+export { NileRichTextEditor } from './nile-rich-text-editor';
+import './version';
+export { NileSideBar } from './nile-side-bar';
+export { NileSideBarHeader } from './nile-side-bar-header';
+export { NileSideBarLogo } from './nile-side-bar-logo';
+export { NileSideBarExpand } from './nile-side-bar-expand';
+export { NileSideBarGroup } from './nile-side-bar-group';
+export { NileSideBarGroupItem } from './nile-side-bar-group-item';
+export { NileSideBarGroupItemIcon } from './nile-side-bar-group-item-icon';
+export { NileSideBarGroupItemText } from './nile-side-bar-group-item-text';
+export { NileSideBarFooter } from './nile-side-bar-footer';
+export { NileSideBarFooterItem } from './nile-side-bar-footer-item';
+export { NileSideBarAction } from './nile-side-bar-action';
+export { NileSideBarFooterText } from './nile-side-bar-footer-text';
+export { NileSideBarActionMenuItem } from './nile-side-bar-action-menu-item';
+export { NileSideBarActionMenu } from './nile-side-bar-action-menu';
+export { NileInlineSidebarGroup } from './nile-inline-sidebar-group';
+export { NileInlineSidebar } from './nile-inline-sidebar';
+export { NileInlineSidebarItem } from './nile-inline-sidebar-item';
+export { NileliteTooltip } from './nile-lite-tooltip';

package/dist/dist/types/src/internal/animate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Animates an element using keyframes. Returns a promise that resolves after the animation completes or gets canceled.
+ */
+export declare function animateTo(el: HTMLElement, keyframes: Keyframe[], options?: KeyframeAnimationOptions): Promise<unknown>;
+/** Parses a CSS duration and returns the number of milliseconds. */
+export declare function parseDuration(delay: number | string): number;
+/** Tells if the user has enabled the "reduced motion" setting in their browser or OS. */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Stops all active animations on the target element. Returns a promise that resolves after all animations are canceled.
+ */
+export declare function stopAnimations(el: HTMLElement): Promise<unknown[]>;
+/**
+ * We can't animate `height: auto`, but we can calculate the height and shim keyframes by replacing it with the
+ * element's scrollHeight before the animation.
+ */
+export declare function shimKeyframesHeightAuto(keyframes: Keyframe[], calculatedHeight: number): {
+    height: string | number | null | undefined;
+    composite?: CompositeOperationOrAuto;
+    easing?: string;
+    offset?: number | null;
+}[];

package/dist/dist/types/src/internal/default-value.d.ts

@@ -0,0 +1,2 @@
+import type { ReactiveElement } from 'lit';
+export declare const defaultValue: (propertyName?: string) => (proto: ReactiveElement, key: string) => void;

package/dist/dist/types/src/internal/drag.d.ts

@@ -0,0 +1,15 @@
+interface DragOptions {
+    /** Callback that runs as dragging occurs. */
+    onMove: (x: number, y: number) => void;
+    /** Callback that runs when dragging stops. */
+    onStop: () => void;
+    /**
+     * When an initial event is passed, the first drag will be triggered immediately using the coordinates therein. This
+     * is useful when the drag is initiated by a mousedown/touchstart event but you want the initial "click" to activate
+     * a drag (e.g. positioning a handle initially at the click target).
+     */
+    initialEvent: PointerEvent;
+}
+/** Begins listening for dragging. */
+export declare function drag(container: HTMLElement, options?: Partial<DragOptions>): void;
+export {};

package/dist/dist/types/src/internal/enum.d.ts

@@ -0,0 +1,20 @@
+export declare const KeyCode: {
+    BACKSPACE: string;
+    TAB: string;
+    ENTER: string;
+    SHIFT: string;
+    CTRL: string;
+    ESCAPE: string;
+    SPACE: string;
+    PAGE_UP: string;
+    PAGE_DOWN: string;
+    END: string;
+    HOME: string;
+    ARROW_LEFT: string;
+    ARROW_UP: string;
+    ARROW_RIGHT: string;
+    ARROW_DOWN: string;
+    CUT: string;
+    COPY: string;
+    PASTE: string;
+};

package/dist/dist/types/src/internal/event.d.ts

@@ -0,0 +1,2 @@
+/** Waits for a specific event to be emitted from an element. Ignores events that bubble up from child elements. */
+export declare function waitForEvent(el: HTMLElement, eventName: string): Promise<void>;

package/dist/dist/types/src/internal/form.d.ts

@@ -0,0 +1,73 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { NileFormControl } from '../internal/nile-element';
+import type { NileButton } from '../nile-button';
+export declare const formCollections: WeakMap<HTMLFormElement, Set<NileFormControl>>;
+export interface FormControlControllerOptions {
+    /** A function that returns the form containing the form control. */
+    form: (input: NileFormControl) => HTMLFormElement | null;
+    /** A function that returns the form control's name, which will be submitted with the form data. */
+    name: (input: NileFormControl) => string;
+    /** A function that returns the form control's current value. */
+    value: (input: NileFormControl) => unknown | unknown[];
+    /** A function that returns the form control's default value. */
+    defaultValue: (input: NileFormControl) => unknown | unknown[];
+    /** A function that returns the form control's current disabled state. If disabled, the value won't be submitted. */
+    disabled: (input: NileFormControl) => boolean;
+    /**
+     * A function that maps to the form control's reportValidity() function. When the control is invalid, this will
+     * prevent submission and trigger the browser's constraint violation warning.
+     */
+    reportValidity: (input: NileFormControl) => boolean;
+    /** A function that sets the form control's value */
+    setValue: (input: NileFormControl, value: unknown) => void;
+    /**
+     * An array of event names to listen to. When all events in the list are emitted, the control will receive validity
+     * states such as user-valid and user-invalid.user interacted validity states. */
+    assumeInteractionOn: string[];
+}
+/** A reactive controller to allow form controls to participate in form submission, validation, etc. */
+export declare class FormControlController implements ReactiveController {
+    host: NileFormControl & ReactiveControllerHost;
+    form?: HTMLFormElement | null;
+    options: FormControlControllerOptions;
+    constructor(host: ReactiveControllerHost & NileFormControl, options?: Partial<FormControlControllerOptions>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    private attachForm;
+    private detachForm;
+    private handleFormData;
+    private handleFormSubmit;
+    private handleFormReset;
+    private handleInteraction;
+    private reportFormValidity;
+    private setUserInteracted;
+    private doAction;
+    /** Returns the associated `<form>` element, if one exists. */
+    getForm(): HTMLFormElement | null;
+    /** Resets the form, restoring all the control to their default value */
+    reset(submitter?: HTMLInputElement | NileButton): void;
+    /** Submits the form, triggering validation and form data injection. */
+    submit(submitter?: HTMLInputElement | NileButton): void;
+    /**
+     * Synchronously sets the form control's validity. Call this when you know the future validity but need to update
+     * the host element immediately, i.e. before Lit updates the component in the next update.
+     */
+    setValidity(isValid: boolean): void;
+    /**
+     * Updates the form control's validity based on the current value of `host.validity.valid`. Call this when anything
+     * that affects constraint validation changes so the component receives the correct validity states.
+     */
+    updateValidity(): void;
+    /**
+     * Dispatches a non-bubbling, cancelable custom event of type `nile-invalid`.
+     * If the `nile-invalid` event will be cancelled then the original `invalid`
+     * event (which may have been passed as argument) will also be cancelled.
+     * If no original `invalid` event has been passed then the `nile-invalid`
+     * event will be cancelled before being dispatched.
+     */
+    emitInvalidEvent(originalInvalidEvent?: Event): void;
+}
+export declare const validValidityState: ValidityState;
+export declare const valueMissingValidityState: ValidityState;
+export declare const customErrorValidityState: ValidityState;

package/dist/dist/types/src/internal/math.d.ts

@@ -0,0 +1,2 @@
+/** Ensures a number stays within a minimum and maximum value */
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/dist/types/src/internal/modal.d.ts

@@ -0,0 +1,12 @@
+export default class Modal {
+    element: HTMLElement;
+    tabDirection: 'forward' | 'backward';
+    constructor(element: HTMLElement);
+    activate(): void;
+    deactivate(): void;
+    isActive(): boolean;
+    checkFocus(): void;
+    handleFocusIn(): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleKeyUp(): void;
+}

package/dist/dist/types/src/internal/nile-element.d.ts

@@ -0,0 +1,29 @@
+import { LitElement } from 'lit';
+export default class NileElement extends LitElement {
+    protected BUBBLES: boolean;
+    protected COMPOSED: boolean;
+    protected CANCELABLE: boolean;
+    /** Emits a custom event with more convenient defaults. */
+    emit(name: string, detail?: any, bubbles?: boolean, composed?: boolean, cancelable?: boolean): CustomEvent<any>;
+}
+export interface NileFormControl extends NileElement {
+    name: string;
+    value: unknown;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    defaultChecked?: boolean;
+    form?: string;
+    pattern?: string;
+    min?: number | string | Date;
+    max?: number | string | Date;
+    step?: number | 'any';
+    required?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    readonly validity: ValidityState;
+    readonly validationMessage: string;
+    checkValidity: () => boolean;
+    getForm: () => HTMLFormElement | null;
+    reportValidity: () => boolean;
+    setCustomValidity: (message: string) => void;
+}

package/dist/dist/types/src/internal/offset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns an element's offset relative to its parent. Similar to element.offsetTop and element.offsetLeft, except the
+ * parent doesn't have to be positioned relative or absolute.
+ *
+ * NOTE: This was created to work around what appears to be a bug in Chrome where a slotted element's offsetParent seems
+ * to ignore elements inside the surrounding shadow DOM: https://bugs.chromium.org/p/chromium/issues/detail?id=920069
+ */
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};

package/dist/dist/types/src/internal/resizable-table-helper.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright Aquera Inc 2025
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resizable Helper Utility
+ * Provides common functionality for resizable table columns
+ */
+export interface ResizeOptions {
+    minWidth?: number;
+    startX: number;
+    startWidth: number;
+    element: HTMLElement;
+}
+export interface ColumnResizeData {
+    columnIndex: number;
+    newWidth: number;
+}
+/**
+ * Handles the start of a resize operation
+ * @param e Mouse event
+ * @param options Resize configuration options
+ * @returns Cleanup function to remove event listeners
+ */
+export declare function handleResizeStart(e: MouseEvent, options: ResizeOptions): () => void;
+/**
+ * Gets the column index of an element within its table row
+ * @param element The table cell or header element
+ * @param selector The CSS selector for the column elements
+ * @returns Column index (0-based)
+ */
+export declare function getColumnIndex(element: HTMLElement, selector: string): number;
+/**
+ * Synchronizes the width of all cells in the same column
+ * @param sourceElement The element that was resized
+ * @param newWidth The new width to apply
+ */
+export declare function synchronizeColumnWidth(sourceElement: HTMLElement, newWidth: number): void;
+/**
+ * Resets all column widths in a table to their default values
+ * @param tableBody The table body element to reset
+ */
+export declare function resetAllColumnWidths(tableBody: HTMLElement): void;
+/**
+ * Checks if an element has the resizable attribute
+ * @param element The element to check
+ * @returns True if the element is resizable
+ */
+export declare function isResizable(element: HTMLElement): boolean;
+/**
+ * Creates a resize handler function for use in component event listeners
+ * @param element The element to make resizable
+ * @param minWidth Minimum width constraint
+ * @returns Event handler function
+ */
+export declare function createResizeHandler(element: HTMLElement, minWidth?: number): (e: MouseEvent) => void;
+/**
+ * Detects if any columns in a table are resizable
+ * @param tableBody The table body element
+ * @returns True if any columns have resizable attribute
+ */
+export declare function hasResizableColumns(tableBody: HTMLElement): boolean;

package/dist/dist/types/src/internal/resizable-table-styles.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resizable Styles Utility
+ * Centralized styles for resizable table functionality
+ */
+export declare const resizableTableStyles: import("lit").CSSResult;
+export declare const resizableHeaderStyles: import("lit").CSSResult;
+export declare const resizerStyles: import("lit").CSSResult;
+export declare const resizableCellStyles: import("lit").CSSResult;
+export declare const headerResizerStyles: import("lit").CSSResult;
+export declare const resizableSlotStyles: import("lit").CSSResult;
+export declare const tableLayoutStyles: import("lit").CSSResult;

package/dist/dist/types/src/internal/scroll.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prevents body scrolling. Keeps track of which elements requested a lock so multiple levels of locking are possible
+ * without premature unlocking.
+ */
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+/**
+ * Unlocks body scrolling. Scrolling will only be unlocked once all elements that requested a lock call this method.
+ */
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+/** Scrolls an element into view of its container. If the element is already in view, nothing will happen. */
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical' | 'both', behavior?: 'smooth' | 'auto'): void;

package/dist/dist/types/src/internal/slot.d.ts

@@ -0,0 +1,23 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A reactive controller that determines when slots exist. */
+export declare class HasSlotController implements ReactiveController {
+    host: ReactiveControllerHost & Element;
+    slotNames: string[];
+    constructor(host: ReactiveControllerHost & Element, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    test(slotName: string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    handleSlotChange(event: Event): void;
+}
+/**
+ * Given a slot, this function iterates over all of its assigned element and text nodes and returns the concatenated
+ * HTML as a string. This is useful because we can't use slot.innerHTML as an alternative.
+ */
+export declare function getInnerHTML(slot: HTMLSlotElement): string;
+/**
+ * Given a slot, this function iterates over all of its assigned text nodes and returns the concatenated text as a
+ * string. This is useful because we can't use slot.textContent as an alternative.
+ */
+export declare function getTextContent(slot: HTMLSlotElement | undefined | null): string;

package/dist/dist/types/src/internal/string.d.ts

@@ -0,0 +1,2 @@
+/** Converts the first letter of a string to uppercase */
+export declare function uppercaseFirstLetter(string: string): string;

package/dist/dist/types/src/internal/tabbable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the first and last bounding elements that are tabbable. This is more performant than checking every single
+ * element because it short-circuits after finding the first and last ones.
+ */
+export declare function getTabbableBoundary(root: HTMLElement | ShadowRoot): {
+    start: HTMLElement | null;
+    end: HTMLElement | null;
+};

package/dist/dist/types/src/internal/watch.d.ts

@@ -0,0 +1,26 @@
+import type { LitElement } from 'lit';
+type UpdateHandler = (prev?: unknown, next?: unknown) => void;
+type NonUndefined<A> = A extends undefined ? never : A;
+type UpdateHandlerFunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends UpdateHandler ? K : never;
+}[keyof T];
+interface WatchOptions {
+    /**
+     * If true, will only start watching after the initial update/render
+     */
+    waitUntilFirstUpdate?: boolean;
+}
+/**
+ * Runs when observed properties change, e.g. @property or @state, but before the component updates. To wait for an
+ * update to complete after a change occurs, use `await this.updateComplete` in the handler. To start watching after the
+ * initial update/render, use `{ waitUntilFirstUpdate: true }` or `this.hasUpdated` in the handler.
+ *
+ * Usage:
+ *
+ * @watch('propName')
+ * handlePropChange(oldValue, newValue) {
+ *   ...
+ * }
+ */
+export declare function watch(propertyName: string | string[], options?: WatchOptions): <ElemClass extends LitElement>(proto: ElemClass, decoratedFnName: UpdateHandlerFunctionKeys<ElemClass>) => void;
+export {};

package/dist/dist/types/src/nile-accordion/nile-accordian.test.d.ts

@@ -0,0 +1 @@
+import './nile-accordion';

package/dist/dist/types/src/nile-accordion/nile-accordion.css.d.ts

@@ -0,0 +1,12 @@
+/**
+* Copyright Aquera Inc 2023
+*
+* This source code is licensed under the BSD-3-Clause license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+/**
+ * Detail CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;

package/dist/dist/types/src/nile-accordion/nile-accordion.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { TemplateResult } from 'lit';
+import NileElement from '../internal/nile-element';
+import type { CSSResultGroup } from 'lit';
+/**
+ * Nile detail component.
+ *
+ * @tag nile-accordion
+ *
+ */
+export declare class NileAccordion extends NileElement {
+    /**
+     * @summary Accordian show a brief summary and expand to show additional content.
+     *
+     * @dependency nile-icon
+     *
+     * @slot - The accordian' main content.
+     * @slot summary - The accordian' summary. Alternatively, you can use the `summary` attribute.
+     * @slot expand-icon - Optional expand icon to use instead of the default. Works best with `<nile-icon>`.
+     * @slot collapse-icon - Optional collapse icon to use instead of the default. Works best with `<nile-icon>`.
+     *
+     * @event nile-show - Emitted when the accordian opens.
+     * @event nile-after-show - Emitted after the accordian opens and all animations are complete.
+     * @event nile-hide - Emitted when the accordian closes.
+     * @event nile-after-hide - Emitted after the accordian closes and all animations are complete.
+     *
+     * @csspart base - The component's base wrapper.
+     * @csspart header - The header that wraps both the summary and the expand/collapse icon.
+     * @csspart summary - The container that wraps the summary.
+     * @csspart summary-icon - The container that wraps the expand/collapse icons.
+     * @csspart content - The accordian content.
+     *
+     * @animation accordian.show - The animation to use when showing accordian. You can use `height: auto` with this animation.
+     * @animation accordian.hide - The animation to use when hiding accordian. You can use `height: auto` with this animation.
+     */
+    static styles: CSSResultGroup;
+    accordian: HTMLElement;
+    header: HTMLElement;
+    body: HTMLElement;
+    expandIconSlot: HTMLSlotElement;
+    /**
+     * Indicates whether or not the accordian is open. You can toggle this attribute to show and hide the accordian, or you
+     * can use the `show()` and `hide()` methods and this attribute will reflect the accordian' open state.
+     */
+    open: boolean;
+    /**
+     * Indicates the visual style of the accordian component. Accepted values are `'dark'` or `'light'`.
+     * Defaults to `'light'`.
+     */
+    variant: 'dark' | 'light';
+    /**
+     * Specifies the direction of the arrow indicator. Accepted values are `'left'` or `'right'`.
+     * Defaults to `'right'`.
+     */
+    expandIconPlacement: 'left' | 'right';
+    /**
+     * Specifies the size of the accordian component. Accepted values are `'sm'`, `'md'`, or `'lg'`.
+     * Defaults to `'md'`.
+     */
+    size: 'sm' | 'md' | 'lg';
+    /** The summary to show in the header. If you need to display HTML, use the `summary` slot instead. */
+    summary: string;
+    /** Disables the accordian so it can't be toggled. */
+    disabled: boolean;
+    firstUpdated(): void;
+    private handleSummaryClick;
+    private handleSummaryKeyDown;
+    handleOpenChange(): Promise<void>;
+    /** Shows the accordian. */
+    show(): Promise<void>;
+    /** Hides the accordian */
+    hide(): Promise<void>;
+    render(): TemplateResult<1>;
+}
+export default NileAccordion;
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-accordion': NileAccordion;
+    }
+}

package/dist/dist/types/src/nile-auto-complete/nile-auto-complete.css.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * AutoComplete CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;