@atlaskit/help 9.1.11 → 9.1.13

package/dist/types-ts4.5/components/ArticlesList/ArticlesListItem/index.d.ts

@@ -3,8 +3,8 @@ import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type ArticleItem } from '../../../model/Article';
 interface Props {
-    styles?: {};
     onClick?: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent) => void;
+    styles?: {};
 }
 export declare const ArticlesListItem: React.FC<Props & Partial<ArticleItem> & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & Partial<ArticleItem> & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/ArticlesList/ArticlesListItem/styled.d.ts

@@ -4,9 +4,9 @@
  */
 import React from 'react';
 export declare const ArticlesListItemWrapper: ({ styles, children, ...rest }: {
+    [rest: string]: any;
     children: React.ReactNode;
     styles?: React.CSSProperties;
-    [rest: string]: any;
 }) => JSX.Element;
 export declare const ArticlesListItemContainer: ({ children }: {
     children: React.ReactNode;
@@ -39,6 +39,6 @@ export declare const ArticlesListItemLastModified: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 export declare const ArticlesListItemDescriptionHighlight: ({ key, children, }: {
-    key: number | string;
     children: React.ReactNode;
+    key: number | string;
 }) => JSX.Element;

package/dist/types-ts4.5/components/ArticlesList/model/ArticlesListItem.d.ts

@@ -1,10 +1,10 @@
 import { type ArticleItem } from '../../../model/Article';
 import type UIAnalyticsEvent from '@atlaskit/analytics-next/UIAnalyticsEvent';
 export interface ArticlesList {
-    style?: 'primary' | 'secondary';
     articles?: ArticleItem[] | null;
-    minItemsToDisplay?: number;
     maxItemsToDisplay?: number;
+    minItemsToDisplay?: number;
     onArticlesListItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem) => void;
     onToggleArticlesList?: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean) => void;
+    style?: 'primary' | 'secondary';
 }

package/dist/types-ts4.5/components/BackButton/index.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 interface Props {
-    onClick(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
     isVisible?: boolean;
+    onClick(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
 }
 export declare const BackButton: React.FC<Props & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/HelpContentButton/index.d.ts

@@ -2,14 +2,14 @@ import React from 'react';
 import { type NotificationLogProvider } from '@atlaskit/notification-log-client';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 export type Props = {
-    id?: string;
     href?: string;
-    notificationMax?: number;
+    icon?: React.ReactChild;
+    id?: string;
     notificationLogProvider?: Promise<NotificationLogProvider>;
+    notificationMax?: number;
+    onClick?: (id: string, analytics: UIAnalyticsEvent, event: React.MouseEvent<HTMLElement>) => void;
     text: string;
-    icon?: React.ReactChild;
     tooltipText?: string;
-    onClick?: (id: string, analytics: UIAnalyticsEvent, event: React.MouseEvent<HTMLElement>) => void;
 };
 declare const HelpContentButton: ({ id, href, notificationMax, notificationLogProvider, text, icon, onClick, tooltipText, }: Props) => React.JSX.Element;
 export default HelpContentButton;

package/dist/types-ts4.5/components/HelpContentButton/styled.d.ts

@@ -4,13 +4,13 @@
  */
 import React from 'react';
 interface HelpContentButtonContainerProps {
-    onClick: (event: React.MouseEvent<HTMLElement>) => void;
-    onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+    children: React.ReactNode;
     href?: string;
     id: string;
+    onClick: (event: React.MouseEvent<HTMLElement>) => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
     tabIndex: number;
     target?: string;
-    children: React.ReactNode;
 }
 export declare const HelpContentButtonContainer: ({ onClick, onKeyDown, href, id, tabIndex, target, children, }: HelpContentButtonContainerProps) => JSX.Element;
 export declare const HelpContentButtonIcon: ({ children }: {
@@ -20,8 +20,8 @@ export declare const HelpContentButtonText: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 export declare const HelpContentButtonExternalLinkIcon: ({ dataTestId, children, }: {
-    dataTestId: string;
     children: React.ReactNode;
+    dataTestId: string;
 }) => JSX.Element;
 export declare const HelpContentButtonExternalNotificationIcon: ({ children, }: {
     children: React.ReactNode;

package/dist/types-ts4.5/components/NeedMoreHelp/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 interface NeedMoreHelpProps {
-    onNeedMoreHelpClick?: () => void;
     label: string;
+    onNeedMoreHelpClick?: () => void;
 }
 export declare const NeedMoreHelp: React.FC<NeedMoreHelpProps>;
 export {};

package/dist/types-ts4.5/components/RelatedArticles/index.d.ts

@@ -8,12 +8,12 @@ import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type ArticleItem } from '../../model/Article';
 export interface Props {
-    style?: 'primary' | 'secondary';
-    routeGroup?: string;
-    routeName?: string;
     onGetRelatedArticles?(routeGroup?: string, routeName?: string): Promise<ArticleItem[]>;
     onRelatedArticlesListItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem) => void;
     onRelatedArticlesShowMoreClick?: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean) => void;
+    routeGroup?: string;
+    routeName?: string;
+    style?: 'primary' | 'secondary';
 }
 export declare const RelatedArticles: React.FC<Props & WrappedComponentProps>;
 declare const _default: React.ForwardRefExoticComponent<Omit<Props & WrappedComponentProps, "intl"> & {

package/dist/types-ts4.5/components/RelatedArticles/styled.d.ts

@@ -7,8 +7,8 @@ export declare const RelatedArticlesTitle: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 export declare const LoadingRelatedArticleList: ({ children, ...rest }: {
-    children: React.ReactNode;
     [rest: string]: any;
+    children: React.ReactNode;
 }) => JSX.Element;
 export declare const LoadingRelatedArticleListItem: ({ children }: {
     children: React.ReactNode;

package/dist/types-ts4.5/components/Search/SearchResults/SearchExternalSite.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 export interface Props {
-    searchExternalUrl?: string;
     onSearchExternalUrlClick?(event?: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
+    searchExternalUrl?: string;
 }
 export declare const SearchExternalSite: React.FC<Props & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/Search/SearchResults/SearchResults.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type ArticleItem } from '../../../model/Article';
 export interface Props {
-    searchResult?: ArticleItem[] | null;
     onSearchResultItemClick(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem): void;
+    searchResult?: ArticleItem[] | null;
 }
 export declare const SearchResults: React.FC<Props>;
 export default SearchResults;

package/dist/types-ts4.5/components/Search/SearchResults/SearchResultsEmpty.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 export interface Props {
-    searchExternalUrl?: string;
     onSearchExternalUrlClick?(event?: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
+    searchExternalUrl?: string;
 }
 export declare const SearchResultsEmpty: React.FC<Props & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/ShowMoreButton/index.d.ts

@@ -3,11 +3,11 @@ import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 export interface Props {
     itemsType?: string;
-    minItemsToDisplay: number;
-    maxItemsToDisplay: number;
-    showMoreToggeled: boolean;
     loading?: boolean;
+    maxItemsToDisplay: number;
+    minItemsToDisplay: number;
     onToggle: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent) => void;
+    showMoreToggeled: boolean;
 }
 export declare const ShowMoreButton: React.FC<Props & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/Tabs/index.d.ts

@@ -3,8 +3,8 @@ interface TabsProps {
     activeTab: number;
     onTabClick: (index: number) => void;
     tabs: {
-        label: string;
         icon: ReactNode;
+        label: string;
     }[];
 }
 declare const Tabs: React.FC<TabsProps>;

package/dist/types-ts4.5/components/Tabs/styled.d.ts

@@ -10,7 +10,7 @@ export declare const TabLabels: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 export declare const TabLabel: ({ isActive, onClick, children, }: {
+    children: React.ReactNode;
     isActive: boolean;
     onClick: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
-    children: React.ReactNode;
 }) => JSX.Element;

package/dist/types-ts4.5/components/WhatsNew/WhatsNewResults/WhatsNewResultsList/WhatsNewResultItem/index.d.ts

@@ -3,8 +3,8 @@ import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type WhatsNewArticleItem } from '../../../../../model/WhatsNew';
 interface Props {
-    styles?: {};
     onClick?: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent) => void;
+    styles?: {};
 }
 export declare const WhatsNewResultListItem: React.FC<Props & Partial<WhatsNewArticleItem> & WrappedComponentProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & Partial<WhatsNewArticleItem> & WrappedComponentProps>> & {

package/dist/types-ts4.5/components/WhatsNew/WhatsNewResults/WhatsNewResultsList/WhatsNewResultItem/styled.d.ts

@@ -4,9 +4,9 @@
  */
 import React from 'react';
 export declare const WhatsNewResultListItemWrapper: ({ styles, children, ...rest }: {
+    [rest: string]: any;
     children: React.ReactNode;
     styles?: React.CSSProperties;
-    [rest: string]: any;
 }) => JSX.Element;
 export declare const WhatsNewResultListItemTitleContainer: ({ children, }: {
     children: React.ReactNode;

package/dist/types-ts4.5/components/WhatsNew/WhatsNewResults/WhatsNewResultsList/model/WhatsNewResultsList.d.ts

@@ -1,11 +1,11 @@
 import { type WhatsNewArticleItem } from '../../../../../model/WhatsNew';
 import type UIAnalyticsEvent from '@atlaskit/analytics-next/UIAnalyticsEvent';
 export interface WhatsNewResultsList {
-    style?: 'primary' | 'secondary';
-    whatsNewArticles?: WhatsNewArticleItem[] | null;
-    nextPage?: string;
     hasNextPage?: boolean;
     loadingMore?: boolean;
-    onWhatsNewResultItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: WhatsNewArticleItem) => void;
+    nextPage?: string;
     onShowMoreButtonClick?: (event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent) => void;
+    onWhatsNewResultItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: WhatsNewArticleItem) => void;
+    style?: 'primary' | 'secondary';
+    whatsNewArticles?: WhatsNewArticleItem[] | null;
 }

package/dist/types-ts4.5/components/WhatsNew/WhatsNewResults/WhatsNewResultsList/styled.d.ts

@@ -7,8 +7,8 @@ export declare const WhatsNewResultsListContainer: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 export declare const WhatsNewResultsListGroupWrapper: ({ key, children, }: {
-    key: string | number;
     children: React.ReactNode;
+    key: string | number;
 }) => JSX.Element;
 export declare const WhatsNewResultsListGroupTitle: ({ children }: {
     children: React.ReactNode;

package/dist/types-ts4.5/components/WhatsNew/WhatsNewResults/WhatsNewResultsLoading/styled.d.ts

@@ -4,8 +4,8 @@
  */
 import React from 'react';
 export declare const LoadingWhatsNewResultsList: ({ children, ...rest }: {
-    children: React.ReactNode;
     [rest: string]: any;
+    children: React.ReactNode;
 }) => JSX.Element;
 export declare const LoadingWhatsNewResultsListItem: ({ children }: {
     children: React.ReactNode;

package/dist/types-ts4.5/components/contexts/aiAgentContext.d.ts

@@ -2,8 +2,8 @@ import React, { type PropsWithChildren } from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 export interface AiContextInterface {
     isAiEnabled?: boolean;
-    onSearchTabClicked?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     onAiTabClicked?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+    onSearchTabClicked?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
 }
 export declare const useAiContext: () => AiContextInterface, CtxProvider: React.Provider<AiContextInterface | undefined>;
 export declare const AiContextProvider: ({ isAiEnabled, onSearchTabClicked, onAiTabClicked, children, }: PropsWithChildren<AiContextInterface>) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/headerContext.d.ts

@@ -1,8 +1,8 @@
 import React, { type PropsWithChildren } from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 interface HeaderSharedInterface {
-    onCloseButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     onBackButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+    onCloseButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
 }
 export declare const useHeaderContext: () => HeaderSharedInterface, CtxProvider: React.Provider<HeaderSharedInterface | undefined>;
 export declare const HeaderContextProvider: ({ onCloseButtonClick, onBackButtonClick, children, }: PropsWithChildren<HeaderSharedInterface>) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/helpArticleContext.d.ts

@@ -5,9 +5,9 @@ import { type articleId } from '../../model/Help';
 export interface HelpArticleContextInterface {
     onGetHelpArticle?(articleId: articleId): Promise<Article>;
     onHelpArticleLoadingFailTryAgainButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleId?: articleId): void;
-    onWasHelpfulYesButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
     onWasHelpfulNoButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
     onWasHelpfulSubmit?(analyticsEvent: UIAnalyticsEvent, articleFeedback: ArticleFeedback, articleData: ArticleItem): Promise<boolean>;
+    onWasHelpfulYesButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
 }
 export declare const useHelpArticleContext: () => HelpArticleContextInterface, CtxProvider: React.Provider<HelpArticleContextInterface | undefined>;
 export declare const HelpArticleContextProvider: ({ onGetHelpArticle, onHelpArticleLoadingFailTryAgainButtonClick, onWasHelpfulYesButtonClick, onWasHelpfulNoButtonClick, onWasHelpfulSubmit, children, }: PropsWithChildren<HelpArticleContextInterface>) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/homeContext.d.ts

@@ -1,8 +1,8 @@
 import React, { type PropsWithChildren } from 'react';
 import type { Props as HelpContentButtonProps } from '../HelpContentButton';
 export interface HomeContextInterface {
-    homeOptions?: HelpContentButtonProps[];
     homeContent?: React.ReactNode;
+    homeOptions?: HelpContentButtonProps[];
 }
 export declare const useHomeContext: () => HomeContextInterface, CtxProvider: React.Provider<HomeContextInterface | undefined>;
 export declare const HomeContextProvider: ({ homeOptions, homeContent, children, }: PropsWithChildren<HomeContextInterface>) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/navigationContext.d.ts

@@ -17,19 +17,19 @@ type NavigationProviderInterface = PropsWithChildren<{
 }>;
 interface NavigationContextInterface {
     articleId?: articleId;
+    canNavigateBack: boolean;
+    getCurrentArticle(): HistoryItem | undefined;
+    getCurrentArticleItemData(): ArticleItem | WhatsNewArticleItem | undefined;
     history?: HistoryItem[];
     historySetter?(history: HistoryItem[]): void;
-    view: ViewType;
-    openArticle(id: articleId): void;
-    canNavigateBack: boolean;
+    isOverlayVisible: boolean;
     navigateBack?(): void;
+    onClose?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     onGetArticle?(id: articleId): Promise<Article | WhatsNewArticle>;
-    getCurrentArticle(): HistoryItem | undefined;
-    getCurrentArticleItemData(): ArticleItem | WhatsNewArticleItem | undefined;
+    openArticle(id: articleId): void;
     reloadHelpArticle?(historyItem: HistoryItem): void;
     reloadWhatsNewArticle?(historyItem: HistoryItem): void;
-    isOverlayVisible: boolean;
-    onClose?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+    view: ViewType;
 }
 export declare const useNavigationContext: () => NavigationContextInterface, CtxProvider: React.Provider<NavigationContextInterface | undefined>;
 export declare const NavigationContextProvider: ({ navigationData, setNavigationData, children, }: NavigationProviderInterface) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/relatedArticlesContext.d.ts

@@ -2,11 +2,11 @@ import React, { type PropsWithChildren } from 'react';
 import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type ArticleItem } from '../../model/Article';
 export interface RelatedArticlesContextInterface {
-    routeGroup?: string;
-    routeName?: string;
     onGetRelatedArticles?(routeGroup?: string, routeName?: string): Promise<ArticleItem[]>;
-    onRelatedArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean): void;
     onRelatedArticlesListItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem) => void;
+    onRelatedArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean): void;
+    routeGroup?: string;
+    routeName?: string;
 }
 export declare const useRelatedArticlesContext: () => RelatedArticlesContextInterface, CtxProvider: React.Provider<RelatedArticlesContextInterface | undefined>;
 export declare const RelatedArticlesContextProvider: ({ routeGroup, routeName, onGetRelatedArticles, onRelatedArticlesShowMoreClick, onRelatedArticlesListItemClick, children, }: PropsWithChildren<RelatedArticlesContextInterface>) => React.JSX.Element;

package/dist/types-ts4.5/components/contexts/searchContext.d.ts

@@ -3,17 +3,17 @@ import { type UIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { type ArticleItem } from '../../model/Article';
 import { REQUEST_STATE } from '../../model/Requests';
 interface SearchSharedInterface {
+    onSearchExternalUrlClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     onSearchInputChanged?(event: React.KeyboardEvent<HTMLInputElement>, analyticsEvent: UIAnalyticsEvent, value: string): void;
     onSearchInputCleared?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
-    onSearchExternalUrlClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
-    searchExternalUrl?: string;
     openExternalSearchUrlInNewTab?: boolean;
+    searchExternalUrl?: string;
     searchOnEnterKeyPress?: boolean;
 }
 export interface SearchContextInterface extends SearchSharedInterface {
+    isSearchResultVisible: boolean;
     onSearch?(value?: string): void;
     onSearchResultItemClick(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem): void;
-    isSearchResultVisible: boolean;
     searchResult: ArticleItem[] | null;
     searchState: REQUEST_STATE;
     searchValue: string;

package/dist/types-ts4.5/components/contexts/whatsNewArticleContext.d.ts

@@ -6,17 +6,17 @@ import { REQUEST_STATE } from '../../model/Requests';
 import { type articleId } from '../../model/Help';
 import { type WHATS_NEW_ITEM_TYPES } from '../../model/WhatsNew';
 interface WhatsNewArticleSharedInterface {
-    whatsNewGetNotificationProvider?: Promise<NotificationLogProvider>;
-    productName?: string;
+    onGetWhatsNewArticle?(id: articleId): Promise<WhatsNewArticle>;
+    onSearchWhatsNewArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent): void;
     onWhatsNewButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     onWhatsNewResultItemClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, whatsNewArticleData: WhatsNewArticleItem): void;
-    onSearchWhatsNewArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent): void;
-    onGetWhatsNewArticle?(id: articleId): Promise<WhatsNewArticle>;
+    productName?: string;
+    whatsNewGetNotificationProvider?: Promise<NotificationLogProvider>;
 }
 interface WhatsNewArticleContextInterface extends WhatsNewArticleSharedInterface {
     onSearchWhatsNewArticles?(filter?: WHATS_NEW_ITEM_TYPES | '', numberOfItems?: number, page?: string): Promise<void>;
-    searchWhatsNewArticlesState: REQUEST_STATE;
     searchWhatsNewArticlesResult: whatsNewSearchResult | null;
+    searchWhatsNewArticlesState: REQUEST_STATE;
 }
 interface WhatsNewArticleProviderInterface extends WhatsNewArticleSharedInterface {
     onSearchWhatsNewArticles?(filter?: WHATS_NEW_ITEM_TYPES | '', numberOfItems?: number, page?: string): Promise<whatsNewSearchResult>;

package/dist/types-ts4.5/components/styled.d.ts

@@ -14,20 +14,20 @@ export declare const HelpBodyAi: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
 type HomeProps = {
+    children: React.ReactNode;
     isOverlayFullyVisible?: boolean;
     isOverlayVisible?: boolean;
-    children: React.ReactNode;
 };
 export declare const Home: ({ isOverlayFullyVisible, isOverlayVisible, children }: HomeProps) => JSX.Element;
 export declare const HomeAi: ({ isOverlayFullyVisible, isOverlayVisible, children }: HomeProps) => JSX.Element;
 export declare const HelpFooter: ({ children, ...rest }: {
-    children: React.ReactNode;
     [rest: string]: any;
+    children: React.ReactNode;
 }) => JSX.Element;
 export declare const BACK_BUTTON_CONTAINER_TRANSITION_DURATION_MS = 220;
 export declare const BackButtonContainer: ({ transitionState, children, }: {
-    transitionState: TransitionStatus;
     children: React.ReactNode;
+    transitionState: TransitionStatus;
 }) => JSX.Element;
 export declare const StyledUl: ({ children }: {
     children: React.ReactNode;

package/dist/types-ts4.5/model/Article.d.ts

@@ -9,28 +9,28 @@ export declare enum ARTICLE_ITEM_TYPES {
     topicInProduct = "topicInProduct"
 }
 export interface ArticleItem {
+    contentAri?: string;
     description?: string;
+    href?: string;
     id: string;
     lastPublished: string;
-    title: string;
-    type: ARTICLE_ITEM_TYPES;
+    productName?: string;
     routes?: {
-        routeName: string;
         routeGroup: string;
+        routeName: string;
     }[];
+    source?: string;
+    title: string;
     topicId?: string;
-    productName?: string;
-    href?: string;
     trustFactors?: {
-        numViews?: number;
         helpfulCount?: number;
+        numViews?: number;
     };
-    source?: string;
-    contentAri?: string;
+    type: ARTICLE_ITEM_TYPES;
 }
 export interface ArticleFeedback {
-    wasHelpful: boolean;
+    contactMe: boolean;
     feedbackReason: string;
     feedbackReasonText: string;
-    contactMe: boolean;
+    wasHelpful: boolean;
 }

package/dist/types-ts4.5/model/Help.d.ts

@@ -9,17 +9,17 @@ export declare enum ARTICLE_TYPE {
     WHATS_NEW = "WHATS_NEW"
 }
 export interface HistoryItem {
-    uid: number;
+    article?: Article | WhatsNewArticle;
+    contentAri?: string;
     id: string;
     state: REQUEST_STATE;
     type: ARTICLE_TYPE;
-    article?: Article | WhatsNewArticle;
-    contentAri?: string;
+    uid: number;
 }
 export interface articleId {
+    contentAri?: string;
     id: string;
     type: ARTICLE_TYPE;
-    contentAri?: string;
 }
 export interface Help {
     ai?: {
@@ -27,24 +27,22 @@ export interface Help {
         onAiTabClicked?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
         onSearchTabClicked?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
     };
+    children?: React.ReactNode;
+    footer?: React.ReactNode;
     header?: {
-        onCloseButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
         onBackButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+        onCloseButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+    };
+    helpArticle?: {
+        onGetHelpArticle?(articleId: articleId): Promise<Article>;
+        onHelpArticleLoadingFailTryAgainButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleId: articleId): void;
+        onWasHelpfulNoButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
+        onWasHelpfulSubmit?(analyticsEvent: UIAnalyticsEvent, articleFeedback: ArticleFeedback, articleData: ArticleItem): Promise<boolean>;
+        onWasHelpfulYesButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
     };
-    footer?: React.ReactNode;
     home?: {
         homeOptions?: HelpContentButtonProps[];
     };
-    search?: {
-        onSearch?(value: string): Promise<ArticleItem[]>;
-        onSearchInputChanged?(event: React.KeyboardEvent<HTMLInputElement>, analyticsEvent: UIAnalyticsEvent, value: string): void;
-        onSearchInputCleared?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
-        onSearchResultItemClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem): void;
-        onSearchExternalUrlClick?(event?: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
-        searchExternalUrl?: string;
-        openExternalSearchUrlInNewTab?: boolean;
-        searchOnEnterKeyPress?: boolean;
-    };
     navigation?: {
         navigationData?: {
             articleId: articleId;
@@ -55,28 +53,30 @@ export interface Help {
             history?: HistoryItem[];
         }): void;
     };
-    helpArticle?: {
-        onGetHelpArticle?(articleId: articleId): Promise<Article>;
-        onHelpArticleLoadingFailTryAgainButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleId: articleId): void;
-        onWasHelpfulSubmit?(analyticsEvent: UIAnalyticsEvent, articleFeedback: ArticleFeedback, articleData: ArticleItem): Promise<boolean>;
-        onWasHelpfulYesButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
-        onWasHelpfulNoButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, ArticleItem: ArticleItem): void;
-    };
     relatedArticles?: {
-        routeGroup?: string;
-        routeName?: string;
         onGetRelatedArticles?(routeGroup?: string, routeName?: string): Promise<ArticleItem[]>;
-        onRelatedArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean): void;
         onRelatedArticlesListItemClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem) => void;
+        onRelatedArticlesShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent, isCollapsed: boolean): void;
+        routeGroup?: string;
+        routeName?: string;
+    };
+    search?: {
+        onSearch?(value: string): Promise<ArticleItem[]>;
+        onSearchExternalUrlClick?(event?: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent?: UIAnalyticsEvent): void;
+        onSearchInputChanged?(event: React.KeyboardEvent<HTMLInputElement>, analyticsEvent: UIAnalyticsEvent, value: string): void;
+        onSearchInputCleared?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+        onSearchResultItemClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, articleData: ArticleItem): void;
+        openExternalSearchUrlInNewTab?: boolean;
+        searchExternalUrl?: string;
+        searchOnEnterKeyPress?: boolean;
     };
     whatsNew?: {
-        whatsNewGetNotificationProvider?: Promise<NotificationLogProvider>;
-        productName?: string;
-        onWhatsNewButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+        onGetWhatsNewArticle?(id: articleId): Promise<WhatsNewArticle>;
         onSearchWhatsNewArticles?(filter?: WHATS_NEW_ITEM_TYPES | '', numberOfItems?: number, page?: string): Promise<whatsNewSearchResult>;
-        onWhatsNewResultItemClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, whatsNewArticleData: WhatsNewArticleItem): void;
         onSearchWhatsNewShowMoreClick?(event: React.MouseEvent<HTMLElement>, analyticsEvent: UIAnalyticsEvent): void;
-        onGetWhatsNewArticle?(id: articleId): Promise<WhatsNewArticle>;
+        onWhatsNewButtonClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent): void;
+        onWhatsNewResultItemClick?(event: React.MouseEvent<HTMLElement, MouseEvent>, analyticsEvent: UIAnalyticsEvent, whatsNewArticleData: WhatsNewArticleItem): void;
+        productName?: string;
+        whatsNewGetNotificationProvider?: Promise<NotificationLogProvider>;
     };
-    children?: React.ReactNode;
 }

package/dist/types-ts4.5/model/WhatsNew.d.ts

@@ -8,22 +8,22 @@ export declare enum WHATS_NEW_ITEM_TYPES {
     EXPERIMENT = "Experiment"
 }
 export interface WhatsNewArticle extends WhatsNewArticleItem {
-    description: string | AdfDoc;
     bodyFormat?: BODY_FORMAT_TYPES;
+    description: string | AdfDoc;
 }
 export interface WhatsNewArticleItem {
-    title?: string;
     changeTargetSchedule?: string;
-    type?: WHATS_NEW_ITEM_TYPES;
-    status?: string;
-    featureRolloutDate?: string;
-    relatedExternalLinks?: string;
     communityUrl?: string;
+    featureRolloutDate?: string;
     href?: string;
     id: string;
+    relatedExternalLinks?: string;
+    status?: string;
+    title?: string;
+    type?: WHATS_NEW_ITEM_TYPES;
 }
 export interface whatsNewSearchResult {
     articles: WhatsNewArticleItem[];
-    nextPage: string;
     hasNextPage: boolean;
+    nextPage: string;
 }

package/dist/types-ts4.5/util/styled.d.ts

@@ -11,15 +11,15 @@ export declare const DividerLine: ({ style }: {
  * Loading container
  */
 type LoadingRectangleProps = {
-    style?: React.CSSProperties;
-    contentWidth?: string;
     contentHeight?: string;
+    contentWidth?: string;
     marginTop?: string;
+    style?: React.CSSProperties;
 };
 export declare const LoadingRectangle: ({ style, contentHeight, contentWidth, marginTop, }: LoadingRectangleProps) => JSX.Element;
 type WhatsNewTypeIconProps = {
-    type?: WHATS_NEW_ITEM_TYPES;
     children?: React.ReactNode;
+    type?: WHATS_NEW_ITEM_TYPES;
 };
 export declare const WhatsNewTypeIcon: ({ type, children }: WhatsNewTypeIconProps) => JSX.Element;
 export {};