@aquera/nile-elements 0.1.38-beta-1.0 → 0.1.38-beta-1.4

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

@@ -0,0 +1,81 @@
+export { NileButton } from './nile-button';
+export { NileHeading } from './nile-heading';
+export { NileIcon } from './nile-icon';
+export { NileInput } from './nile-input';
+export { NileSidebar } from './nile-sidebar';
+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 { 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 { NileSidebarMenu } from './nile-sidebar-menu';
+export { NileSidebarMenuItems } from './nile-sidebar-menu-items';
+export { NileSidebarWrapper } from './nile-sidebar-wrapper';
+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 { NileFileUpload } from './nile-file-upload';
+export { NileFilePreview } from './nile-file-preview';

package/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/types/src/nile-accordion/index.d.ts

@@ -0,0 +1 @@
+export { NileAccordion } from './nile-accordion';

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

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

package/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/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/types/src/nile-auto-complete/index.d.ts

@@ -0,0 +1 @@
+export { NileAutoComplete } from './nile-auto-complete';

package/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;

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

@@ -0,0 +1,39 @@
+import { TemplateResult } from 'lit';
+import NileElement from '../internal/nile-element';
+import type { CSSResultGroup, PropertyValues } from 'lit';
+import { NileDropdown } from '../nile-dropdown';
+export declare class NileAutoComplete extends NileElement {
+    static styles: CSSResultGroup;
+    dropdownElement: NileDropdown;
+    disabled: boolean;
+    isDropdownOpen: boolean;
+    enableVirtualScroll: boolean;
+    openOnFocus: boolean;
+    value: string;
+    placeholder: string;
+    noBorder: boolean;
+    noOutline: boolean;
+    loading: boolean;
+    filterFunction: (item: string, searchedValue: string) => boolean;
+    renderItemFunction: (item: any) => string;
+    allMenuItems: any;
+    menuItems: any;
+    connectedCallback(): void;
+    protected updated(changedProperties: PropertyValues): void;
+    render(): TemplateResult;
+    getVirtualizedContent(): TemplateResult;
+    getContent(): TemplateResult;
+    getItemRenderFunction(item: any): TemplateResult;
+    private handleSelect;
+    private setVirtualMenuWidth;
+    private handleSearch;
+    handleFocus(): void;
+    private handleClick;
+    applyFilter<T>(list: T[], filterFn: (item: T, searchValue?: string) => boolean): T[];
+}
+export default NileAutoComplete;
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-auto-complete': NileAutoComplete;
+    }
+}

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

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

package/dist/types/src/nile-avatar/index.d.ts

@@ -0,0 +1 @@
+export { NileAvatar } from './nile-avatar';

package/dist/types/src/nile-avatar/nile-avatar.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.
+ */
+/**
+ * Avatar CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;

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

@@ -0,0 +1,53 @@
+/**
+ * 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 { CSSResultArray, TemplateResult } from 'lit';
+import NileElement from '../internal/nile-element';
+/**
+ * Nile icon component.
+ *
+ * @tag nile-avatar
+ *
+ */
+export declare class NileAvatar extends NileElement {
+    /**
+     * The styles for Avatar
+     * @remarks If you are extending this class you can extend the base styles with super. Eg `return [super(), myCustomStyles]`
+     */
+    static get styles(): CSSResultArray;
+    /** Gives the url to the Avatar */
+    src: string;
+    /** Gives the icon to the Avatar */
+    variant: 'icon' | 'image' | 'text';
+    /** Gives the icon to the Avatar */
+    icon: string;
+    /** Gives the default Image Letters to the Avatar */
+    name: String;
+    /** Gives the default bg color  to the Avatar */
+    bgColor: string;
+    /** Gives the default text color  to the Avatar */
+    textColor: string;
+    /** Gives the default border color  to the Avatar */
+    borderColor: string;
+    /** Size of the Avatar */
+    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    /** Gives a border radius of 50% to the Avatar */
+    isRounded: boolean;
+    private imageError;
+    private generateInitials;
+    private generateVariantCode;
+    private getDefaultIconSize;
+    render(): TemplateResult;
+    getContentWrapped(content: TemplateResult, defaultInitials: string): TemplateResult<1>;
+    getIconContent(): TemplateResult<1>;
+    getImageContent(): TemplateResult<1>;
+}
+export default NileAvatar;
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-avatar': NileAvatar;
+    }
+}

package/dist/types/src/nile-avatar/nile-avatar.test.d.ts

@@ -0,0 +1,2 @@
+import './nile-avatar';
+import '../nile-icon';

package/dist/types/src/nile-badge/index.d.ts

@@ -0,0 +1 @@
+export { NileBadge } from './nile-badge';

package/dist/types/src/nile-badge/nile-badge.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.
+ */
+/**
+ * Tag CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;