stargazer-ui 1.0.5 → 1.0.7

package/dist/esm/types/components/Card/Card.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import { CardBodyType, CardFooterType, CardTextType, CardType } from "./Card.types";
+declare const _default: React.ForwardRefExoticComponent<Omit<CardType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Header: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLDivElement | HTMLHeadingElement | HTMLSpanElement>>;
+    Body: React.ForwardRefExoticComponent<Omit<CardBodyType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLHeadingElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<CardTextType, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Footer: React.ForwardRefExoticComponent<Omit<CardFooterType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export default _default;

package/dist/esm/types/components/Card/Card.types.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import { BaseDivType, BaseHeadingType, BaseSpanType, BaseParagraphType } from "../../BaseTypes";
+export type CardType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type CardHeaderPossible = BaseDivType | BaseSpanType | BaseHeadingType;
+export type CardHeaderType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & CardHeaderPossible;
+export type CardBodyType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type CardTextType = {
+    children: ReactNode;
+    className?: string;
+} & BaseParagraphType;
+export type CardFooterType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;

package/dist/esm/types/components/Card/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Card";

package/dist/esm/types/components/CloseButton/CloseButton.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { CloseButtonType } from "./CloseButton.types";
+declare const CloseButton: React.ForwardRefExoticComponent<Omit<CloseButtonType, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export default CloseButton;

package/dist/esm/types/components/CloseButton/CloseButton.types.d.ts

@@ -0,0 +1,5 @@
+import { BaseButtonType } from "../../BaseTypes";
+export type CloseButtonType = {
+    className?: string;
+    variant?: boolean;
+} & BaseButtonType;

package/dist/esm/types/components/CloseButton/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./CloseButton";

package/dist/esm/types/components/Dropdown/Dropdown.d.ts

@@ -0,0 +1,71 @@
+import React from "react";
+import { DropdownContextType, DropdownDividerType, DropdownMenuType, DropdownType } from "./Dropdown.types";
+export declare const DropdownContext: React.Context<DropdownContextType | null>;
+export declare const DropdownContextProvider: ({ children, value }: {
+    children: React.ReactNode;
+    value: DropdownContextType;
+}) => React.JSX.Element;
+export declare const useDropdownContext: () => DropdownContextType;
+export declare const Toggle: React.ForwardRefExoticComponent<(Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    navDropdown?: boolean | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    variant?: string | undefined;
+} & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    navDropdown?: boolean | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    variant?: string | undefined;
+} & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    navDropdown?: boolean | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    variant?: string | undefined;
+} & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+export declare const Menu: React.ForwardRefExoticComponent<Omit<DropdownMenuType, "ref"> & React.RefAttributes<HTMLUListElement>>;
+export declare const Item: React.ForwardRefExoticComponent<(Omit<{
+    children: React.ReactNode;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    className?: string | undefined;
+} & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    className?: string | undefined;
+} & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+export declare const Divider: React.ForwardRefExoticComponent<Omit<DropdownDividerType, "ref"> & React.RefAttributes<HTMLHRElement>>;
+declare const _default: React.ForwardRefExoticComponent<Omit<DropdownType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Toggle: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Menu: React.ForwardRefExoticComponent<Omit<DropdownMenuType, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Divider: React.ForwardRefExoticComponent<Omit<DropdownDividerType, "ref"> & React.RefAttributes<HTMLHRElement>>;
+};
+export default _default;

package/dist/esm/types/components/Dropdown/Dropdown.types.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from "react";
+import { BaseDivType, BaseAnchorType, BaseButtonType, BaseUListType, BaseHrType, BaseElementType } from "../../BaseTypes";
+export type DropdownContextType = {
+    align: string;
+    drop: string;
+    showInternal: boolean;
+    handleToggle: Function;
+    placement: string;
+    directionClasses?: {
+        down?: string;
+        'down-centered'?: string;
+        up?: string;
+        'up-centered'?: string;
+        end?: string;
+        start?: string;
+    };
+    controlId: string;
+    activeDescendant: {
+        case: string;
+    };
+    setActiveDescendant: React.Dispatch<React.SetStateAction<{
+        case: string;
+    }>>;
+};
+export type DropdownType = {
+    children: ReactNode;
+    className?: string;
+    onSelect?: Function;
+    onToggle?: Function;
+    controlId: string;
+    drop?: string;
+    align?: string;
+    autoClose?: boolean;
+    show?: boolean;
+} & BaseDivType;
+export type DropdownToggleType = {
+    children: ReactNode;
+    className?: string;
+    navDropdown?: boolean;
+    as?: React.ElementType;
+    variant?: string;
+} & (BaseAnchorType | BaseButtonType | BaseElementType);
+export type DropdownMenuType = {
+    children: ReactNode;
+    className?: string;
+    style?: React.CSSProperties | undefined;
+} & BaseUListType;
+export type DropdownItemType = {
+    children: ReactNode;
+    as?: React.ElementType;
+    className?: string;
+} & (BaseAnchorType | BaseButtonType);
+export type DropdownDividerType = {
+    className?: string;
+} & BaseHrType;

package/dist/esm/types/components/Dropdown/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Dropdown";

package/dist/esm/types/components/FloatingLabel/FloatingLabel.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { FloatingLabelType } from "./FloatingLabel.types";
+declare const FloatingLabel: React.ForwardRefExoticComponent<Omit<FloatingLabelType, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+export default FloatingLabel;

package/dist/esm/types/components/FloatingLabel/FloatingLabel.types.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { BaseLabelType } from "../../BaseTypes";
+export type FloatingLabelType = {
+    children: ReactNode;
+    className?: string;
+    htmlFor?: string;
+    label: string;
+    controlId: string;
+} & BaseLabelType;

package/dist/esm/types/components/FloatingLabel/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./FloatingLabel";

package/dist/esm/types/components/Form/Form.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { FormCheckType, FormContextType, FormControlType, FormGroupType, FormLabelType, FormSelectType, FormTextType, FormType } from "./Form.types";
+export declare const FormContext: React.Context<FormContextType | null>;
+export declare const FormContextProvider: ({ children, value }: {
+    children: React.ReactNode;
+    value: FormContextType;
+}) => React.JSX.Element;
+export declare const useFormContext: () => FormContextType;
+declare const _default: React.ForwardRefExoticComponent<Omit<FormType, "ref"> & React.RefAttributes<HTMLFormElement>> & {
+    Control: React.ForwardRefExoticComponent<Omit<FormControlType, "ref"> & React.RefAttributes<HTMLInputElement>>;
+    Select: React.ForwardRefExoticComponent<Omit<FormSelectType, "ref"> & React.RefAttributes<HTMLSelectElement>>;
+    Group: React.ForwardRefExoticComponent<Omit<FormGroupType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<FormLabelType, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+    Check: React.ForwardRefExoticComponent<Omit<FormCheckType, "ref"> & React.RefAttributes<HTMLInputElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<FormTextType, "ref"> & React.RefAttributes<HTMLElement>>;
+};
+export default _default;

package/dist/esm/types/components/Form/Form.types.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from "react";
+import { BaseDivType, BaseFormType, BaseInputType, BaseLabelType, BaseSelectType, BaseSmallType } from "../../BaseTypes";
+export type FormContextType = {
+    controlId: string;
+};
+export type FormType = {
+    children: ReactNode;
+} & BaseFormType;
+export type FormControlType = {
+    as?: React.ElementType;
+    className?: string;
+    plaintext?: boolean;
+    id?: string;
+    type?: string;
+    autoFocus?: boolean;
+} & BaseInputType;
+export type FormSelectType = {
+    children: ReactNode;
+    className?: string;
+    id?: string;
+} & BaseSelectType;
+export type FormGroupType = {
+    children: ReactNode;
+    className?: string;
+    controlId: string;
+} & BaseDivType;
+export type FormLabelType = {
+    children: ReactNode;
+    className?: string;
+    htmlFor?: string;
+} & BaseLabelType;
+export type FormCheckType = {
+    classNameContainer?: string;
+    containerRef?: React.LegacyRef<HTMLDivElement>;
+    containerId?: string;
+    style?: React.CSSProperties;
+    classNameLabel?: string;
+    labelRef?: React.LegacyRef<HTMLLabelElement>;
+    label?: string;
+    labelId?: string;
+    className?: string;
+    type?: string;
+    controlId?: string;
+    reverse?: boolean;
+    checkStyle?: React.CSSProperties;
+} & BaseInputType;
+export type FormTextType = {
+    children: ReactNode;
+    className?: string;
+} & BaseSmallType;

package/dist/esm/types/components/Form/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Form";

package/dist/esm/types/components/InputGroup/InputGroup.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { InputGroupText, InputGroupType } from "./InputGroup.types";
+declare const _default: React.ForwardRefExoticComponent<Omit<InputGroupType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Text: React.ForwardRefExoticComponent<InputGroupText & React.RefAttributes<HTMLSpanElement>>;
+};
+export default _default;

package/dist/esm/types/components/InputGroup/InputGroup.types.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import { BaseDivType } from "../../BaseTypes";
+export type InputGroupType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type InputGroupText = {
+    children: ReactNode;
+    className?: string;
+};

package/dist/esm/types/components/InputGroup/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./InputGroup";

package/dist/esm/types/components/Modal/Modal.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+import { ModalBodyType, ModalType } from "./Modal.types";
+declare const _default: (({ children, centered, size, show, backdrop, onHide, className, id, ...restProps }: ModalType) => React.ReactPortal) & {
+    Header: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+        closeButton?: boolean | undefined;
+        onClick?: ((event: React.MouseEvent<Element, MouseEvent>) => void) | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+        closeButton?: boolean | undefined;
+        onClick?: ((event: React.MouseEvent<Element, MouseEvent>) => void) | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+        closeButton?: boolean | undefined;
+        onClick?: ((event: React.MouseEvent<Element, MouseEvent>) => void) | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLDivElement | HTMLHeadingElement | HTMLSpanElement>>;
+    Title: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLDivElement | HTMLHeadingElement | HTMLSpanElement>>;
+    Body: React.ForwardRefExoticComponent<Omit<ModalBodyType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<Omit<ModalBodyType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export default _default;
+export declare const useKeepElementFocused: (elementRef: React.RefObject<HTMLDialogElement>) => void;

package/dist/esm/types/components/Modal/Modal.types.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from "react";
+import { BaseDialogType, BaseDivType, BaseHeadingType, BaseSpanType } from "../../BaseTypes";
+export type ModalContextType = Function | null;
+export type ModalType = {
+    children: ReactNode;
+    className?: string;
+    id?: string;
+    centered?: boolean;
+    size?: string;
+    show: boolean;
+    backdrop?: string;
+    onHide: Function;
+} & BaseDialogType;
+export type ModalHeaderType = {
+    children: ReactNode;
+    as?: React.ElementType;
+    className?: string;
+    closeButton?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+} & (BaseDivType | BaseHeadingType | BaseSpanType);
+export type ModalTitleType = {
+    children: ReactNode;
+    as?: React.ElementType;
+    className?: string;
+} & (BaseDivType | BaseHeadingType | BaseSpanType);
+export type ModalBodyType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type ModalFooterType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type ErrorModalType = {
+    typeCheck: {
+        show: boolean;
+        onHide: boolean;
+    };
+    closeModal: Function;
+};

package/dist/esm/types/components/Modal/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Modal";

package/dist/esm/types/components/Nav/Nav.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+declare const _default: React.ForwardRefExoticComponent<(Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+} & React.ClassAttributes<HTMLUListElement> & React.HTMLAttributes<HTMLUListElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+} & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLElement>> & {
+    Item: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLLIElement> & React.LiHTMLAttributes<HTMLLIElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLElement>>;
+    Link: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLElement>>;
+};
+export default _default;

package/dist/esm/types/components/Nav/Nav.types.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { BaseAnchorType, BaseElementType, BaseLItemType, BaseUListType } from "../../BaseTypes";
+export type NavType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & (BaseUListType | BaseElementType);
+export type NavItemType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & (BaseLItemType | BaseElementType);
+export type NavLinkType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & (BaseAnchorType | BaseElementType);

package/dist/esm/types/components/Nav/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Nav";

package/dist/esm/types/components/NavBar/Navbar.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { NavbarTextType, NavbarType } from "./Navbar.types";
+export type NavbarContextType = string | null;
+export declare const NavbarContext: React.Context<NavbarContextType>;
+export declare const useNavbarContext: () => NavbarContextType;
+declare const _default: React.ForwardRefExoticComponent<Omit<NavbarType, "ref"> & React.RefAttributes<HTMLElement>> & {
+    Brand: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        href?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        href?: string | undefined;
+    } & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<NavbarTextType, "ref"> & React.RefAttributes<HTMLElement>>;
+};
+export default _default;

package/dist/esm/types/components/NavBar/Navbar.types.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from "react";
+import { BaseAnchorType, BaseElementType, BaseNavType } from "../../BaseTypes";
+export type NavbarType = {
+    children: ReactNode;
+    className?: string;
+    navbarPrefix?: string;
+} & BaseNavType;
+export type NavbarBrandType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+    href?: string;
+} & (BaseAnchorType | BaseElementType);
+export type NavbarTextType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & BaseElementType;

package/dist/esm/types/components/NavBar/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Navbar";

package/dist/esm/types/components/NavDropdown/NavDropdown.d.ts

@@ -0,0 +1,35 @@
+import React from "react";
+import { NavDropdownType } from "./NavDropdown.types";
+declare const _default: React.ForwardRefExoticComponent<Omit<NavDropdownType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Toggle: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLElement> & React.HTMLAttributes<HTMLElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Menu: React.ForwardRefExoticComponent<Omit<import("../Dropdown/Dropdown.types").DropdownMenuType, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Divider: React.ForwardRefExoticComponent<Omit<import("../Dropdown/Dropdown.types").DropdownDividerType, "ref"> & React.RefAttributes<HTMLHRElement>>;
+};
+export default _default;

package/dist/esm/types/components/NavDropdown/NavDropdown.types.d.ts

@@ -0,0 +1,5 @@
+import { DropdownType } from "../Dropdown/Dropdown.types";
+export type NavDropdownType = {
+    toggleProps?: any;
+    menuProps?: any;
+} & DropdownType;

package/dist/esm/types/components/NavDropdown/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./NavDropdown";

package/dist/esm/types/components/Popout/Popout.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import { PopoutType, PopoutBodyType, PopoutFooterType, PopoutTextType, PopoutTitleType } from "./Popout.types";
+declare const _default: React.ForwardRefExoticComponent<Omit<PopoutType, "ref"> & React.RefAttributes<HTMLDialogElement>> & {
+    Header: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLDivElement | HTMLHeadingElement | HTMLSpanElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<PopoutTitleType, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Body: React.ForwardRefExoticComponent<Omit<PopoutBodyType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<PopoutTextType, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Footer: React.ForwardRefExoticComponent<Omit<PopoutFooterType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export default _default;

package/dist/esm/types/components/Popout/Popout.types.d.ts

@@ -0,0 +1,36 @@
+import { ReactNode } from "react";
+import { BaseDialogType, BaseDivType, BaseHeadingType, BaseParagraphType, BaseSpanType } from "../../BaseTypes";
+export type PopoutType = {
+    children: ReactNode;
+    initialPosition?: {
+        top?: number;
+        bottom?: number;
+        right?: number;
+        left?: number;
+    };
+    id?: string;
+    resize?: boolean;
+    move?: boolean;
+} & BaseDialogType;
+export type PopoutHeaderType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & (BaseDivType | BaseHeadingType | BaseSpanType);
+export type PopoutTitleType = {
+    children: ReactNode;
+    className?: string;
+    as?: React.ElementType;
+} & BaseHeadingType;
+export type PopoutBodyType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;
+export type PopoutTextType = {
+    children: ReactNode;
+    className?: string;
+} & BaseParagraphType;
+export type PopoutFooterType = {
+    children: ReactNode;
+    className?: string;
+} & BaseDivType;

package/dist/esm/types/components/Popout/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Popout";

package/dist/esm/types/components/Spinner/Spinner.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { SpinnerType } from "./Spinner.types";
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerType & React.RefAttributes<HTMLDivElement>>;
+export default Spinner;

package/dist/esm/types/components/Spinner/Spinner.types.d.ts

@@ -0,0 +1,7 @@
+export type SpinnerType = {
+    label: string;
+    size?: string;
+    color?: string;
+    className?: string;
+    controlId?: string;
+};

package/dist/esm/types/components/Spinner/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Spinner";