@ganpatiinfo/gids-core-web 14.0.0 → 15.1.0

package/dist/types/components/html/GidsMatrixTableBody/GidsMatrixTableBody.d.ts

@@ -2,10 +2,30 @@ import { JSXBase } from '../../../stencil-public-runtime';
 import { GidsMatrixTableBodyWebProps, GidsTableCellTypographyStyle } from '@ganpatiinfo/gids-web-shared';
 import { IconAppearance, IconName } from '@ganpatiinfo/gids-web-theme-interface';
 import { GidsMatrixTableBodyActionButtonEvent } from '@ganpatiinfo/gids-core-shared';
+/**
+ * @deprecated
+ *
+ * Use `GidsCrossTableBody` and its props and functions instead.
+ */
 type GidsMatrixTableBodyBaseWebProps = GidsMatrixTableBodyWebProps<GidsTableCellTypographyStyle, IconName, IconAppearance>;
+/**
+ * @deprecated
+ *
+ * Use `GidsCrossTableBody` and its props and functions instead.
+ */
 export type GidsMatrixTableBodyActionButtonBaseEvent = GidsMatrixTableBodyActionButtonEvent<Event, GidsTableCellTypographyStyle, IconName, IconAppearance>;
+/**
+ * @deprecated
+ *
+ * Use `GidsCrossTableBody` and its props and functions instead.
+ */
 export interface GidsMatrixTableBodyProps extends GidsMatrixTableBodyBaseWebProps, Omit<JSXBase.IntrinsicElements['tbody'], 'children'> {
     onClickMatrixBodyCellActionBtn?: (event: GidsMatrixTableBodyActionButtonBaseEvent) => void;
 }
+/**
+ * @deprecated
+ *
+ * Use `GidsCrossTableBody` and its props and functions instead.
+ */
 export declare const GidsMatrixTableBody: ({ width, tableBodyItems, tableBorders, rowAppearance, rowLabelTypography, rowTextAlignment, matrixHeaderAppearance, matrixHeaderLabelTypography, matrixHeaderTextAlignment, rowCellPrimaryActionButtons, rowCellSecondaryActionButtons, matrixHeaderCellPrimaryActionButtons, matrixHeaderCellSecondaryActionButtons, onClickMatrixBodyCellActionBtn, class: className, }: GidsMatrixTableBodyProps) => any;
 export {};

package/dist/types/components/html/GidsMenu/GidsMenu.d.ts

@@ -1,6 +1,6 @@
-import { FunctionalComponent, VNode } from '../../../stencil-public-runtime';
+import { VNode } from '../../../stencil-public-runtime';
 import { JSXBase } from '../../../stencil-public-runtime';
 import { GidsMenuWebProps } from '@ganpatiinfo/gids-web-shared';
-export interface GidsMenuProps extends GidsMenuWebProps<VNode, VNode | string>, Omit<JSXBase.IntrinsicElements['div'], 'children' | 'onClick'> {
+export interface GidsMenuProps extends Omit<GidsMenuWebProps<VNode, VNode | string>, 'children'>, Omit<JSXBase.IntrinsicElements['div'], 'onClick'> {
 }
-export declare const GidsMenu: FunctionalComponent<GidsMenuProps>;
+export declare const GidsMenu: ({ heading, supportingText, level, supportingTextTypography, isHeaderDividerVisible, class: className, ...restProps }: GidsMenuProps, children: VNode) => any;

package/dist/types/components/html/GidsMenuGroup/GidsMenuGroup.d.ts

@@ -1,5 +1,5 @@
 import { VNode } from '../../../stencil-public-runtime';
-import { FunctionalComponent, JSXBase } from '../../../stencil-public-runtime';
+import { JSXBase } from '../../../stencil-public-runtime';
 import { GidsMenuGroupWebProps } from '@ganpatiinfo/gids-web-shared';
-export type GidsMenuGroupProps = GidsMenuGroupWebProps<VNode> & Omit<JSXBase.IntrinsicElements['div'], 'children' | 'onClick'>;
-export declare const GidsMenuGroup: FunctionalComponent<GidsMenuGroupProps>;
+export type GidsMenuGroupProps = Omit<GidsMenuGroupWebProps<VNode>, 'children'> & Omit<JSXBase.IntrinsicElements['div'], 'onClick'>;
+export declare const GidsMenuGroup: ({ type, supportingText, class: className, ...rest }: GidsMenuGroupProps, children: VNode) => any;

package/dist/types/components/html/GidsTable/GidsTable.d.ts

@@ -12,5 +12,5 @@ export interface GidsTableProps extends GidsTableBaseWebProps {
     extraClasses?: string;
     onTableAction?: (event: GidsTableActionBaseEvent) => void;
 }
-export declare const GidsTable: ({ toolbar, headerItems, bodyContent, isHeaderVisible, isToolbarVisible, bodySettings, toolbarSettings, headerSettings, tableBorders, tableBorderRadius, tableBodyMaxHeight, toolbarChildren, onTableAction, horizontalScroll, class: className, ...restProps }: GidsTableProps, children: VNode) => any;
+export declare const GidsTable: ({ toolbar, headerItems, bodyContent, isHeaderVisible, isToolbarVisible, bodySettings, toolbarSettings, headerSettings, tableBorders, tableBorderRadius, tableBodyMaxHeight, toolbarChildren, onTableAction, horizontalScroll, footerItems, footerSettings, isFooterVisible, isFooterControlVisible, footerControlSettings, footerControl, class: className, ...restProps }: GidsTableProps, children: VNode) => any;
 export {};

package/dist/types/components/html/GidsTableFooter/GidsTableFooter.d.ts

@@ -3,10 +3,10 @@ import { GidsTableEntryTypographyStyle, GidsTableFooterWebProps } from '@ganpati
 import { IconAppearance, IconName } from '@ganpatiinfo/gids-web-theme-interface';
 import { GidsTableFooterActionEvent } from '@ganpatiinfo/gids-core-shared';
 import { JSXBase } from '../../../stencil-public-runtime';
-export type GidsTableFooterNativeInputForwardedProps = Partial<Omit<HTMLInputElement, 'value' | 'readOnly' | 'name' | 'disabled'>>;
-export type GidsTableFooterBaseWebProps = Omit<GidsTableFooterWebProps<GidsTableEntryTypographyStyle, IconName, IconAppearance, VNode, VNode, GidsTableFooterNativeInputForwardedProps, Event>, 'children'> & Omit<JSXBase.IntrinsicElements['tfoot'], 'children'>;
+export type GidsTableFooterNativeInputForwardedProps = Partial<Omit<JSXBase.IntrinsicElements['input'], 'value' | 'readOnly' | 'name' | 'disabled'>>;
+export type GidsTableFooterBaseWebProps = Omit<GidsTableFooterWebProps<GidsTableEntryTypographyStyle, IconName, IconAppearance, VNode>, 'children'> & Omit<JSXBase.IntrinsicElements['tfoot'], 'children'>;
 export type GidsTableFooterActionBaseEvent = GidsTableFooterActionEvent<Event, GidsTableEntryTypographyStyle, IconName, IconAppearance>;
 export interface GidsTableFooterProps extends GidsTableFooterBaseWebProps {
     onFooterAction?: (event: GidsTableFooterActionBaseEvent) => void;
 }
-export declare const GidsTableFooter: ({ appearance, labelTypography, textAlignment, leadingActions, trailingActions, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, footerControlSettings, footerControlChildren, footerItems, onFooterAction, class: className, ...restProps }: GidsTableFooterProps, children: VNode) => any;
+export declare const GidsTableFooter: ({ appearance, labelTypography, textAlignment, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, footerItems, onFooterAction, class: className, ...restProps }: GidsTableFooterProps, children: VNode) => any;

package/dist/types/components/html/GidsTableFooterControl/GidsTableFooterControl.d.ts

@@ -5,4 +5,4 @@ import { JSXBase } from '../../../stencil-public-runtime';
 export type TableFooterNativeInputForwardedProps = Omit<JSXBase.IntrinsicElements['input'], 'disabled' | 'readOnly' | 'value' | 'name'>;
 export type GidsTableFooterControlBaseWebProps = Omit<GidsTableFooterControlWebProps<IconName, VNode, TableFooterNativeInputForwardedProps, VNode, Event>, 'children'> & Omit<JSXBase.IntrinsicElements['div'], 'children' | 'onChange' | 'onClick'>;
 export type GidsTableFooterControlProps = GidsTableFooterControlBaseWebProps;
-export declare const GidsTableFooterControl: ({ bulkStatus, rangeStatus, tableViewControllerSettings, paginatorSettings, tableViewControllerVisible, paginatorVisible, class: className, }: GidsTableFooterControlProps, children: VNode) => any;
+export declare const GidsTableFooterControl: ({ appearance, bulkStatus, rangeStatus, tableViewControllerSettings, paginatorSettings, tableViewControllerVisible, paginatorVisible, class: className, }: GidsTableFooterControlProps, children: VNode) => any;

package/dist/types/components/html/GidsTableHeader/GidsTableHeader.d.ts

@@ -6,4 +6,4 @@ export type GidsTableHeaderActionBaseEvent = GidsTableHeaderActionEvent<Event, G
 export interface GidsTableHeaderProps extends Omit<GidsTableHeaderWebProps<GidsTableEntryTypographyStyle, IconName, IconAppearance, VNode>, 'children'>, Omit<JSXBase.IntrinsicElements['thead'], 'children'> {
     onHeaderAction?: (event: GidsTableHeaderActionBaseEvent) => void;
 }
-export declare const GidsTableHeader: ({ headerItems, appearance, labelTypography, textAlignment, leadingActions, trailingActions, onHeaderAction, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, class: className, ...restProps }: GidsTableHeaderProps, children: VNode) => any;
+export declare const GidsTableHeader: ({ headerItems, appearance, labelTypography, textAlignment, onHeaderAction, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, class: className, ...restProps }: GidsTableHeaderProps, children: VNode) => any;

package/dist/types/components/html/GidsTableRow/GidsTableRow.d.ts

@@ -6,4 +6,4 @@ export type GidsTableRowActionBaseEvent = GidsTableRowActionEvent<Event, GidsTab
 export interface GidsTableRowProps extends Omit<GidsTableRowWebProps<GidsTableEntryTypographyStyle, IconName, IconAppearance, never>, 'children' | 'onChange'>, Omit<JSXBase.IntrinsicElements['tr'], 'children'> {
     onRowAction?: (event: GidsTableRowActionBaseEvent) => void;
 }
-export declare const GidsTableRow: ({ rows, rowType, leadingActions, trailingActions, onRowAction, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, textAlignment, labelTypography, appearance, actionsBackgroundColor, actionsContentColor, backgroundColor, contentColor, class: className, ...restProps }: GidsTableRowProps, children: VNode) => any;
+export declare const GidsTableRow: ({ rows, rowType, onRowAction, entryAlignment, colorSwatchLabelColor, colorSwatchLabelPosition, colorSwatchLabelTypography, colorSwatchSize, colorSwatchShape, colorSwatchShadow, colorSwatchBorderRadius, colorSwatchApplyBorders, colorSwatchBorderWidth, progressBarSize, progressBarEndCap, avatarSize, avatarGroupAppearance, avatarGroupLayout, statusTagAppearance, statusTagSize, progressBarContainerMinWidth, displayTagsOrientation, statusTagsOrientation, progressBarsOrientation, colorSwatchesOrientation, badgesOrientation, textAlignment, labelTypography, appearance, actionsBackgroundColor, actionsContentColor, backgroundColor, contentColor, class: className, ...restProps }: GidsTableRowProps, children: VNode) => any;

package/dist/types/components/html/_GidsDialogControl/GidsDialogControl.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from '../../../stencil-public-runtime';
+import { GidsDialogControlWebProps } from '@ganpatiinfo/gids-web-shared';
+import { IconAppearance, IconName } from '@ganpatiinfo/gids-web-theme-interface';
+import { JSXBase } from '../../../stencil-public-runtime';
+type GidsDialogControlBaseWebProps = Omit<GidsDialogControlWebProps<VNode | string, Event, IconName, IconAppearance>, 'children'> & Omit<JSXBase.IntrinsicElements['dialog'], 'children'>;
+export type GidsDialogControlProps = GidsDialogControlBaseWebProps;
+export declare const GidsDialogControl: ({ variant, maxWidth, scrollMode, draggable, headerTitle, closeVisible, footerActions, headerDividerVisible, footerDividerVisible, onCloseDialogControl, onDialogControlFooterAction, class: className, }: GidsDialogControlProps, children: VNode | string) => any;
+export {};

package/dist/types/components/webComponents/GidsHeaderNavigation/GidsHeaderNavigation.d.ts

@@ -0,0 +1,51 @@
+import { GidsHeaderNavigationWebProps } from '@ganpatiinfo/gids-web-shared';
+import { IconName } from '@ganpatiinfo/gids-web-theme-interface';
+import { GidsHeaderNavigationItemAppearance, GidsHeaderNavigationItemBorderRadius, GidsHeaderNavigationItemSelectionType, GidsHeaderNavigationItemSize, GidsHeaderNavigationMenu, GidsHeaderNavigationMenuItemEvent, GidsHeaderNavigationMode, GidsHeaderNavigationType } from '@ganpatiinfo/gids-core-shared';
+type GidsHeaderNavigationPressCustomEvent = Event | MouseEvent;
+export type GidsHeaderNavigationBaseWebProps = GidsHeaderNavigationWebProps<GidsHeaderNavigationPressCustomEvent, IconName>;
+export declare class GidsHeaderNavigation implements GidsHeaderNavigationBaseWebProps {
+    private hostElement;
+    appearance?: GidsHeaderNavigationItemAppearance;
+    selectionAppearance?: GidsHeaderNavigationItemAppearance;
+    type?: GidsHeaderNavigationType;
+    selectionType?: GidsHeaderNavigationItemSelectionType;
+    defaultNavItemId?: string;
+    defaultNavMenuId?: string;
+    defaultNavMenuItemId?: string;
+    applyShadow?: boolean;
+    applySeparators?: boolean;
+    borderRadius?: GidsHeaderNavigationItemBorderRadius;
+    mode?: GidsHeaderNavigationMode;
+    size?: GidsHeaderNavigationItemSize;
+    navMenus?: GidsHeaderNavigationMenu<IconName>[];
+    onHeaderNavigationItemChange?: (event: GidsHeaderNavigationMenuItemEvent<GidsHeaderNavigationPressCustomEvent>) => void;
+    selectedItemIdsState?: string[];
+    selectedMenuItemIdsState?: string[];
+    expandedMenuIdsState?: string[];
+    protected appearanceChanged(next: GidsHeaderNavigationItemAppearance): void;
+    protected selectionAppearanceChanged(next: GidsHeaderNavigationItemAppearance): void;
+    protected borderRadiusChanged(next: GidsHeaderNavigationItemBorderRadius): void;
+    protected shadowChanged(next: boolean): void;
+    protected sizeChanged(next: GidsHeaderNavigationItemSize): void;
+    protected separatorsChanged(next: boolean): void;
+    protected modeChanged(next: GidsHeaderNavigationMode): void;
+    protected defaultNavItemIdChanged(): void;
+    protected defaultNavMenuIdChanged(): void;
+    protected defaultNavMenuItemIdChanged(): void;
+    protected navMenusChanged(next: GidsHeaderNavigationMenu<IconName>[]): void;
+    protected typeChanged(next: GidsHeaderNavigationType): void;
+    connectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    private onNavigationItemPress;
+    private onNavigationMenuItemChange;
+    private handleDocumentClick;
+    private handleSelectionsAndExpansions;
+    private isThisMenuExpanded;
+    private isThisNavigationItemSelected;
+    private getSelectedMenuItemId;
+    private initializeDefaultSelection;
+    render(): any;
+}
+export {};

package/dist/types/components/webComponents/GidsHeaderNavigationItem/GidsHeaderNavigationItem.d.ts

@@ -0,0 +1,42 @@
+import { GidsHeaderNavigationItemWebProps } from '@ganpatiinfo/gids-web-shared';
+import { GidsHeaderNavigationItemAppearance, GidsHeaderNavigationItemBorderRadius, GidsHeaderNavigationItemEvent, GidsHeaderNavigationItemMenuGroupItem, GidsHeaderNavigationItemMenuItemEvent, GidsHeaderNavigationItemSelectedMenuItem, GidsHeaderNavigationItemSelectionType, GidsHeaderNavigationItemSize } from '@ganpatiinfo/gids-core-shared';
+export type GidsHeaderNavigationItemCustomEvent = Event | MouseEvent;
+export type GidsHeaderNavigationItemBaseWebProps = GidsHeaderNavigationItemWebProps<GidsHeaderNavigationItemCustomEvent, never>;
+export declare class GidsHeaderNavigationItem implements GidsHeaderNavigationItemBaseWebProps {
+    private hostElement;
+    id: string;
+    menuId?: string;
+    expanded?: boolean;
+    borderRadius?: GidsHeaderNavigationItemBorderRadius;
+    applyShadow?: boolean;
+    appearance?: GidsHeaderNavigationItemAppearance;
+    selectionAppearance?: GidsHeaderNavigationItemAppearance;
+    selected?: boolean;
+    selectedMenuItemId?: string;
+    label?: string;
+    size?: GidsHeaderNavigationItemSize;
+    selectionType?: GidsHeaderNavigationItemSelectionType;
+    menuItems?: GidsHeaderNavigationItemMenuGroupItem[];
+    onPressNavigationItem?: (event: GidsHeaderNavigationItemEvent<GidsHeaderNavigationItemCustomEvent>) => void;
+    onMenuItemChange?: (event: GidsHeaderNavigationItemMenuItemEvent<GidsHeaderNavigationItemCustomEvent>) => void;
+    isSelected?: boolean;
+    isMenuExpanded?: boolean;
+    selectedMenuItems: GidsHeaderNavigationItemSelectedMenuItem[];
+    protected appearanceChanged(next: GidsHeaderNavigationItemAppearance): void;
+    protected selectionAppearanceChanged(next: GidsHeaderNavigationItemAppearance): void;
+    protected expansionChanged(next: boolean): void;
+    protected borderRadiusChanged(next: GidsHeaderNavigationItemBorderRadius): void;
+    protected shadowChanged(next: boolean): void;
+    protected labelChanged(next: string): void;
+    protected sizeChanged(next: GidsHeaderNavigationItemSize): void;
+    protected menuItemsChanged(next: GidsHeaderNavigationItemMenuGroupItem[]): void;
+    protected selectedChanged(next: boolean): void;
+    protected selectedMenuItemIdChanged(next: string): void;
+    connectedCallback(): void;
+    private onItemClick;
+    private onMenuItemClick;
+    private defaultSelectedMenuItems;
+    private hasMenu;
+    private isMenuItemSelected;
+    render(): any;
+}

package/dist/types/components/webComponents/GidsProfile/GidsProfile.d.ts

@@ -0,0 +1,64 @@
+import { GidsProfileWebProps } from '@ganpatiinfo/gids-web-shared';
+import { IconAppearance, IconName } from '@ganpatiinfo/gids-web-theme-interface';
+import { GidsIconSize, GidsProfileAppearance, GidsProfileBorderRadius, GidsProfileControlAvatarProps, GidsProfileControlEvent, GidsProfileMenuGroupedItem, GidsProfileMenuHeaderItem, GidsProfileMenuHeaderItemPressEvent, GidsProfileMenuItemEvent, GidsProfileShadow } from '@ganpatiinfo/gids-core-shared';
+type GidsProfilePressCustomEvents = Event | MouseEvent;
+export type GidsProfileBaseWebProps = GidsProfileWebProps<GidsProfilePressCustomEvents, IconName, IconAppearance, string>;
+export declare class GidsProfile implements GidsProfileBaseWebProps {
+    private hostElement;
+    id: string;
+    menuId?: string;
+    expanded?: boolean;
+    profileControlAppearance?: GidsProfileAppearance;
+    profileControlAvatarProps?: GidsProfileControlAvatarProps<string>;
+    profileControlAvatarVisible?: boolean;
+    profileControlAvatarBadgeVisible?: boolean;
+    profileControlBorderRadius?: GidsProfileBorderRadius;
+    profileControlShadow?: GidsProfileShadow;
+    profileControlLeadingIcon?: IconName;
+    profileControlTrailingIcon?: IconName;
+    profileControlLeadingIconSize?: GidsIconSize;
+    profileControlTrailingIconSize?: GidsIconSize;
+    profileControlLeadingIconAppearance?: IconAppearance;
+    profileControlTrailingIconAppearance?: IconAppearance;
+    profileControlTitle?: string;
+    profileControlSupportingText?: string;
+    profileMenuItems?: GidsProfileMenuGroupedItem[];
+    headerDividerVisible?: boolean;
+    headerVisible?: boolean;
+    headerItem?: GidsProfileMenuHeaderItem<GidsProfilePressCustomEvents, string>;
+    listSectionDividerVisible?: boolean;
+    onHeaderAvatarPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfilePressCustomEvents, string>) => void;
+    onHeaderTitlePress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfilePressCustomEvents, string>) => void;
+    onHeaderSupportingTextPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfilePressCustomEvents, string>) => void;
+    onProfileMenuItemPress?: (event: GidsProfileMenuItemEvent<GidsProfilePressCustomEvents>) => void;
+    onPressProfileControl?: (event: GidsProfileControlEvent<GidsProfilePressCustomEvents>) => void;
+    isMenuExpanded?: boolean;
+    protected idChanged(next: string): void;
+    protected profileControlAppearanceChanged(next: GidsProfileAppearance): void;
+    protected profileControlAvatarPropsChanged(next: GidsProfileControlAvatarProps<string>): void;
+    protected expansionChanged(next: boolean): void;
+    protected profileControlAvatarVisibleChanged(next: boolean): void;
+    protected profileControlAvatarBadgeVisibleChanged(next: boolean): void;
+    protected profileControlBorderRadiusChanged(next: GidsProfileBorderRadius): void;
+    protected profileControlShadowChanged(next: GidsProfileShadow): void;
+    protected listSectionDividerVisibleChanged(next: boolean): void;
+    protected profileControlLeadingIconChanged(next: IconName): void;
+    protected profileControlTrailingIconChanged(next: IconName): void;
+    protected profileControlTitleChanged(next: string): void;
+    protected profileControlSupportingTextChanged(next: string): void;
+    protected headerDividerVisibleChanged(next: boolean): void;
+    protected headerItemChanged(next: GidsProfileMenuHeaderItem<GidsProfilePressCustomEvents, string>): void;
+    protected headerVisibleChanged(next: boolean): void;
+    protected profileMenuItemsChanged(next: GidsProfileMenuGroupedItem[]): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    private onProfileControlPress;
+    private onPressProfileMenuItem;
+    private getProfileControlAvatarText;
+    private hasHeaderItem;
+    private hasMenu;
+    private handleDocumentClick;
+    render(): any;
+}
+export {};

package/dist/types/components/webComponents/GidsProfileMenu/GidsProfileMenu.d.ts

@@ -0,0 +1,29 @@
+import { GidsProfileMenuWebProps } from '@ganpatiinfo/gids-web-shared';
+import { GidsProfileMenuGroupedItem, GidsProfileMenuHeaderItem, GidsProfileMenuHeaderItemPressEvent, GidsProfileMenuItemEvent, GidsProfileMenuItemEventDetails } from '@ganpatiinfo/gids-core-shared';
+type GidsProfileMenuPressCustomEvents = Event | MouseEvent;
+export type GidsProfileMenuBaseWebProps = GidsProfileMenuWebProps<GidsProfileMenuPressCustomEvents, string>;
+export declare class GidsProfileMenu implements GidsProfileMenuBaseWebProps {
+    private hostElement;
+    headerItem?: GidsProfileMenuHeaderItem<GidsProfileMenuPressCustomEvents, string>;
+    headerVisible?: boolean;
+    listSectionDividerVisible?: boolean;
+    headerDividerVisible?: boolean;
+    profileMenuItems?: GidsProfileMenuGroupedItem[];
+    onHeaderAvatarPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuPressCustomEvents, string>) => void;
+    onHeaderTitlePress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuPressCustomEvents, string>) => void;
+    onHeaderSupportingTextPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuPressCustomEvents, string>) => void;
+    onProfileMenuItemPress?: (event: GidsProfileMenuItemEvent<GidsProfileMenuPressCustomEvents>) => void;
+    selectedProfileMenuItem?: GidsProfileMenuItemEventDetails;
+    protected headerItemChanged(next: GidsProfileMenuHeaderItem<GidsProfileMenuPressCustomEvents, string>): void;
+    protected headerVisibleChanged(next: boolean): void;
+    protected profileMenuItemsChanged(next: GidsProfileMenuGroupedItem[]): void;
+    connectedCallback(): void;
+    private onListItemPress;
+    private profileMenuItemSelection;
+    private isItemAlreadySelected;
+    private isThisItemSelected;
+    private hasHeaderItem;
+    private hasProfileMenuItems;
+    render(): any;
+}
+export {};

package/dist/types/components/webComponents/GidsProfileMenuHeader/GidsProfileMenuHeader.d.ts

@@ -0,0 +1,30 @@
+import { GidsProfileMenuHeaderWebProps } from '@ganpatiinfo/gids-web-shared';
+import { GidsProfileMenuHeaderAvatarProps, GidsProfileMenuHeaderItemPressEvent, GidsProfileMenuHeaderItemsPosition } from '@ganpatiinfo/gids-core-shared';
+type GidsProfileMenuHeaderPressCustomEvents = Event | MouseEvent;
+export type GidsProfileMenuHeaderBaseWebProps = GidsProfileMenuHeaderWebProps<GidsProfileMenuHeaderPressCustomEvents, string>;
+export declare class GidsProfileMenuHeader implements GidsProfileMenuHeaderBaseWebProps {
+    private hostElement;
+    avatarProps?: GidsProfileMenuHeaderAvatarProps<string>;
+    headerItemsPosition?: GidsProfileMenuHeaderItemsPosition;
+    headerTitle?: string;
+    headerSupportingText?: string;
+    avatarVisible?: boolean;
+    avatarBadgeVisible?: boolean;
+    onHeaderAvatarPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuHeaderPressCustomEvents, string>) => void;
+    onHeaderTitlePress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuHeaderPressCustomEvents, string>) => void;
+    onHeaderSupportingTextPress?: (event: GidsProfileMenuHeaderItemPressEvent<GidsProfileMenuHeaderPressCustomEvents, string>) => void;
+    protected avatarPropsChanged(next: GidsProfileMenuHeaderAvatarProps<string>): void;
+    protected headerItemsPositionChanged(next: GidsProfileMenuHeaderItemsPosition): void;
+    protected headerTitleChanged(next: string): void;
+    protected headerSupportingTextChanged(next: string): void;
+    protected avatarVisibilityChanged(next: boolean): void;
+    protected avatarBadgeVisibilityChanged(next: boolean): void;
+    connectedCallback(): void;
+    private onAvatarItemPress;
+    private onHeaderItemTitlePress;
+    private onHeaderItemSupportingTextPress;
+    private pressHeaderItems;
+    private getAvatarText;
+    render(): any;
+}
+export {};

package/dist/types/components/webComponents/GidsSkeleton/GidsSkeleton.d.ts

@@ -0,0 +1,11 @@
+import { type GidsSkeletonWebProps } from '@ganpatiinfo/gids-web-shared';
+import { GidsSkeletonAnimation, GidsSkeletonVariant } from '@ganpatiinfo/gids-core-shared';
+export declare class GidsSkeleton implements GidsSkeletonWebProps {
+    variant?: GidsSkeletonVariant;
+    animation?: GidsSkeletonAnimation;
+    width?: string | number;
+    height?: string | number;
+    private getDimension;
+    private getStyle;
+    render(): any;
+}

package/dist/types/components/webComponents/GidsTransferList/GidsTransferList.d.ts

@@ -0,0 +1,49 @@
+import { GidsTransferListListItem, GidsTransferListSelectEvent, GidsTransferListTransferActionEvent, GidsTransferListType } from '@ganpatiinfo/gids-core-shared';
+import { GidsTransferListWebProps } from '@ganpatiinfo/gids-web-shared';
+export type GidsTransferListEventType = Event | MouseEvent;
+type GidsTransferListBaseWebProps = GidsTransferListWebProps<GidsTransferListEventType>;
+export declare class GidsTransferList implements GidsTransferListBaseWebProps {
+    private hostElement;
+    leftListHeading?: string;
+    rightListHeading?: string;
+    moveAllVisible?: boolean;
+    transferListType?: GidsTransferListType;
+    leftListItems?: GidsTransferListListItem[];
+    rightListItems?: GidsTransferListListItem[];
+    listsMaxHeight?: string;
+    onTransferAction?: (event: GidsTransferListTransferActionEvent<GidsTransferListEventType>) => void;
+    onTransferListSelect?: (event: GidsTransferListSelectEvent<GidsTransferListEventType>) => void;
+    private leftListItemsState?;
+    private rightListItemsState?;
+    private tempLeftListItemsState?;
+    private tempRightListItemsState?;
+    protected handleListsMaxHeightChange(next: string): void;
+    protected handleLeftListHeadingChange(next: string): void;
+    protected handleRightListHeadingChange(next: string): void;
+    protected handleMoveAllVisibilityChange(next: boolean): void;
+    protected handleTransferListTypeChange(next: GidsTransferListType): void;
+    protected handleLeftListItemsChange(next: GidsTransferListListItem[]): void;
+    protected handleRightListItemsChange(next: GidsTransferListListItem[]): void;
+    componentDidLoad(): void;
+    private setListItemsStates;
+    private getListHeading;
+    private getListSupportingText;
+    private isAllItemsSelectedInList;
+    private isAtleastOneItemSelectedInList;
+    private renderListHeading;
+    private listItemSelection;
+    private onPressingListItem;
+    private selectUnselectListItem;
+    private isItemSelected;
+    private getStateListsItemsArr;
+    private getTempListsItemsArr;
+    private selectUnselectAllItems;
+    private callOnTransferListSelectFunc;
+    private movementButtonDisabled;
+    private callOnTransferAction;
+    private clearListSystem;
+    private moveListItems;
+    private onItemsMovement;
+    render(): any;
+}
+export {};