stargazer-ui 1.5.21 → 1.5.23

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./BaseTypes"
+export * from "./createFastContext"
+export * from "./MergeClassnames"
+export * from "./MergeRefs"

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/tsconfig-build.json

@@ -0,0 +1,4 @@
+{
+    "extends": "./tsconfig.json",
+    "include": ["src"]
+  }

package/tsconfig.json

@@ -0,0 +1,79 @@
+{
+	"compilerOptions": {
+		"target": "esnext",
+		"module": "ESNext",
+    "lib": ["dom", "esnext"],
+		"jsx": "react-jsx",
+		"sourceMap": true,
+		"strict": true,
+		"moduleResolution": "node",
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"declaration": true,
+		"declarationDir": "dist",
+		"emitDeclarationOnly": true
+	},
+	"exclude": ["node_modules", "**/*stories", "**/*types", "holding area", "legacy"]
+}
+
+
+/*
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "dist",
+    "emitDeclarationOnly": true,
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": [
+    "dist",
+    "node_modules",
+  ]
+
+}
+*/
+
+/*
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    //Bundler mode 
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    // Linting 
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}
+*/

package/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/types/BaseTypes.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+export type BaseAnchorType = React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
+export type BaseButtonType = React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+export type BaseDialogType = React.DetailedHTMLProps<React.DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
+export type BaseDivType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type BaseFormType = React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
+export type BaseHeadingType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+export type BaseInputType = React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export type BaseHrType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
+export type BaseLabelType = React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+export type BaseLItemType = React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
+export type BaseNavType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+export type BaseParagraphType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+export type BaseSelectType = React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
+export type BaseSmallType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+export type BaseSpanType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+export type BaseTableType = React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
+export type BaseUListType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
+export type BaseElementType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;

package/{Button → types/components/Button}/Button.types.d.ts

@@ -1,6 +1,7 @@
 import { ReactNode } from "react";
+import { BaseButtonType } from "../../BaseTypes";
 export type ButtonType = {
     children: ReactNode;
     variant?: string;
     className?: string;
-} & React.ComponentPropsWithRef<"button">;
+} & BaseButtonType;

package/types/components/Button/index.d.ts

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

package/{Card → types/components/Card}/Card.d.ts

@@ -3,30 +3,30 @@ import { CardBodyType, CardFooterType, CardTextType, CardType } from "./Card.typ
 declare const _default: React.ForwardRefExoticComponent<Omit<CardType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
     Header: React.ForwardRefExoticComponent<(Omit<{
         children: React.ReactNode;
-        className?: string;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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>>;

package/{Card → types/components/Card}/Card.types.d.ts

@@ -1,10 +1,8 @@
 import { ReactNode } from "react";
-import { BaseDivType, BaseHeadingType, BaseSpanType, BaseParagraphType } from "../utils/BaseTypes";
+import { BaseDivType, BaseHeadingType, BaseSpanType, BaseParagraphType } from "../../BaseTypes";
 export type CardType = {
     children: ReactNode;
     className?: string;
-    variant?: string;
-    inverted?: boolean;
 } & BaseDivType;
 export type CardHeaderPossible = BaseDivType | BaseSpanType | BaseHeadingType;
 export type CardHeaderType = {

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

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

package/{CloseButton → types/components/CloseButton}/CloseButton.types.d.ts

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

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

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

package/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/{Dropdown → types/components/Dropdown}/Dropdown.types.d.ts

@@ -1,10 +1,19 @@
 import { ReactNode } from "react";
-import { BaseAnchorType, BaseButtonType, BaseUListType, BaseHrType, BaseLItemType } from "../utils/BaseTypes";
+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;
@@ -12,12 +21,10 @@ export type DropdownContextType = {
     setActiveDescendant: React.Dispatch<React.SetStateAction<{
         case: string;
     }>>;
-    navDropdown: boolean;
 };
 export type DropdownType = {
     children: ReactNode;
     className?: string;
-    navDropdown?: boolean;
     onSelect?: Function;
     onToggle?: Function;
     controlId: string;
@@ -25,21 +32,14 @@ export type DropdownType = {
     align?: string;
     autoClose?: boolean;
     show?: boolean;
-    label: string;
-    as?: React.ElementType;
-    variant?: string;
-    menuRef?: any;
-    menuProps: DropdownMenuType;
-} & BaseButtonType;
+} & BaseDivType;
 export type DropdownToggleType = {
     children: ReactNode;
     className?: string;
-    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
     navDropdown?: boolean;
     as?: React.ElementType;
     variant?: string;
-    label: string;
-} & BaseButtonType;
+} & (BaseAnchorType | BaseButtonType | BaseElementType);
 export type DropdownMenuType = {
     children: ReactNode;
     className?: string;
@@ -49,7 +49,6 @@ export type DropdownItemType = {
     children: ReactNode;
     as?: React.ElementType;
     className?: string;
-    liProps: BaseLItemType;
 } & (BaseAnchorType | BaseButtonType);
 export type DropdownDividerType = {
     className?: string;

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

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

package/{FloatingLabel → types/components/FloatingLabel}/FloatingLabel.types.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
-import { BaseLabelType } from "../utils/BaseTypes";
+import { BaseLabelType } from "../../BaseTypes";
 export type FloatingLabelType = {
     children: ReactNode;
     className?: string;

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

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

package/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/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/types/components/Form/index.d.ts

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

package/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/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/types/components/InputGroup/index.d.ts

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

package/{Modal → types/components/Modal}/Modal.d.ts

@@ -1,37 +1,37 @@
 import React from "react";
 import { ModalBodyType, ModalType } from "./Modal.types";
-declare const _default: React.ForwardRefExoticComponent<Omit<ModalType, "ref"> & React.RefAttributes<HTMLDialogElement>> & {
+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;
-        className?: string;
-        closeButton?: boolean;
-        onClick?: (event: React.MouseEvent) => void;
+        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;
-        className?: string;
-        closeButton?: boolean;
-        onClick?: (event: React.MouseEvent) => void;
+        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;
-        className?: string;
-        closeButton?: boolean;
-        onClick?: (event: React.MouseEvent) => void;
+        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;
-        className?: string;
+        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;
-        className?: string;
+        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;
-        className?: string;
+        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>>;

package/{Modal → types/components/Modal}/Modal.types.d.ts

@@ -1,16 +1,15 @@
 import { ReactNode } from "react";
-import { BaseDialogType, BaseDivType, BaseHeadingType, BaseSpanType } from "../utils/BaseTypes";
+import { BaseDialogType, BaseDivType, BaseHeadingType, BaseSpanType } from "../../BaseTypes";
 export type ModalContextType = Function | null;
 export type ModalType = {
     children: ReactNode;
     className?: string;
     id?: string;
-    fill?: boolean;
+    centered?: boolean;
     size?: string;
     show: boolean;
     backdrop?: string;
     onHide: Function;
-    stretch?: boolean;
 } & BaseDialogType;
 export type ModalHeaderType = {
     children: ReactNode;

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

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

package/{Nav → types/components/Nav}/Nav.d.ts

@@ -1,30 +1,30 @@
 import React from "react";
 declare const _default: React.ForwardRefExoticComponent<(Omit<{
     children: React.ReactNode;
-    className?: string;
-    as?: React.ElementType;
+    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;
-    as?: React.ElementType;
+    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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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;
-        as?: React.ElementType;
+        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/{Nav → types/components/Nav}/Nav.types.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
-import { BaseAnchorType, BaseElementType, BaseLItemType, BaseUListType } from "../utils/BaseTypes";
+import { BaseAnchorType, BaseElementType, BaseLItemType, BaseUListType } from "../../BaseTypes";
 export type NavType = {
     children: ReactNode;
     className?: string;

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

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

package/{NavBar → types/components/NavBar}/Navbar.d.ts

@@ -1,18 +1,19 @@
 import React from "react";
-import { NavbarTextType, NavbarType, NavbarContextType } from "./Navbar.types";
+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;
-        as?: React.ElementType;
-        href?: string;
+        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;
-        as?: React.ElementType;
-        href?: string;
+        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>>;
 };

package/{NavBar → types/components/NavBar}/Navbar.types.d.ts

@@ -1,6 +1,5 @@
 import { ReactNode } from "react";
-import { BaseAnchorType, BaseElementType, BaseNavType } from "../utils/BaseTypes";
-export type NavbarContextType = string | null;
+import { BaseAnchorType, BaseElementType, BaseNavType } from "../../BaseTypes";
 export type NavbarType = {
     children: ReactNode;
     className?: string;

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

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