@rh-support/troubleshoot 2.7.1 → 2.7.11

package/lib/esm/hooks/useCaseUpdateErrorMessage.js

@@ -1,17 +1,114 @@
-import { formattedApiErrorMessage, ToastNotification } from '@rh-support/components';
+import { AlertActionLink } from '@patternfly/react-core';
+import { getDirectErrorMessage, ToastNotification } from '@rh-support/components';
+import React from 'react';
 import { useTranslation } from 'react-i18next';
-// TO DO
+const PICKLIST_VALIDATION_PATTERN = /is not a valid active picklist value/i;
+const CASE_GROUP_REQUIRED_PATTERN = /group.*required|required.*group/i;
+function isCaseUpdateErrorContent(value) {
+    return typeof value === 'object' && value !== null && 'title' in value && 'message' in value;
+}
+/**
+ * Extracts the raw error string from a GraphQL or REST error object,
+ * checking common shapes (ApolloError, plain Error, API response).
+ */
+function extractRawMessage(e) {
+    if (!e || typeof e !== 'object')
+        return '';
+    const err = e;
+    const graphQLErrors = err.graphQLErrors;
+    if (Array.isArray(graphQLErrors) && graphQLErrors.length > 0) {
+        return graphQLErrors.map((g) => g.message || '').join('; ');
+    }
+    const errors = err.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+        return errors.map((g) => g.message || '').join('; ');
+    }
+    return [err.message, err.detailMessage, err.statusText, err.responseText]
+        .filter((v) => typeof v === 'string' && v.length > 0)
+        .join(' ')
+        .trim();
+}
+export function getErrorStatusCode(error) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!error || typeof error !== 'object') {
+        return parseStatusFromMessage(String(error !== null && error !== void 0 ? error : ''));
+    }
+    const e = error;
+    const fromCode = Number.parseInt(String((_b = (_a = e.code) !== null && _a !== void 0 ? _a : e.status) !== null && _b !== void 0 ? _b : ''), 10);
+    if (fromCode) {
+        return fromCode;
+    }
+    const fromNetwork = Number.parseInt(String((_f = (_d = (_c = e.networkError) === null || _c === void 0 ? void 0 : _c.statusCode) !== null && _d !== void 0 ? _d : (_e = e.networkError) === null || _e === void 0 ? void 0 : _e.status) !== null && _f !== void 0 ? _f : ''), 10);
+    if (fromNetwork) {
+        return fromNetwork;
+    }
+    return parseStatusFromMessage(String(e.message || ''));
+}
+function parseStatusFromMessage(message) {
+    const match = message.match(/status code\s+(\d+)/i);
+    return match ? Number.parseInt(match[1], 10) : 0;
+}
+export function isGenericNetworkError(error) {
+    const message = typeof error === 'string' ? error : String((error === null || error === void 0 ? void 0 : error.message) || '');
+    return /Response not successful|Failed to fetch|Network request failed|NetworkError when attempting to fetch|Received status code\s+\d+/i.test(message);
+}
 export function useCaseUpdateErrorMessage() {
     const { t } = useTranslation();
-    const showError = (e, message500) => {
-        const errorMessage = formattedApiErrorMessage(e, {
-            '500': { title: t('There was a problem with your request'), message: message500 },
-            '403': {
-                title: t('There was a problem with your request'),
-                message: t('You are not authorized to update this case.'),
-            },
+    const showDesignedError = (content) => {
+        ToastNotification.addDangerMessage(content.title, content.message, {
+            closeOnClick: false,
+            actionLinks: (closeToast) => (React.createElement(React.Fragment, null,
+                React.createElement(AlertActionLink, { "data-tracking-id": "case-update-error-try-again", onClick: () => {
+                        closeToast === null || closeToast === void 0 ? void 0 : closeToast();
+                        if (content.onRetry) {
+                            void content.onRetry();
+                        }
+                        else {
+                            window.location.reload();
+                        }
+                    } }, t('Try again')),
+                React.createElement(AlertActionLink, { "data-tracking-id": "case-update-error-refresh", onClick: () => window.location.reload() }, t('Refresh the page')))),
+        });
+    };
+    const showError = (e, fallbackOrContent) => {
+        const errorCode = getErrorStatusCode(e);
+        const rawMessage = extractRawMessage(e);
+        if (errorCode === 403) {
+            ToastNotification.addDangerMessage(t('There was a problem with your request'), t('You are not authorized to update this case.'));
+            return;
+        }
+        if (PICKLIST_VALIDATION_PATTERN.test(rawMessage)) {
+            ToastNotification.addDangerMessage(t('The value you selected is no longer valid. Please choose a different option and try again.'));
+            return;
+        }
+        if (CASE_GROUP_REQUIRED_PATTERN.test(rawMessage)) {
+            ToastNotification.addDangerMessage(t('Case Group is required for this account and cannot be removed.'));
+            return;
+        }
+        if (isCaseUpdateErrorContent(fallbackOrContent)) {
+            showDesignedError(fallbackOrContent);
+            return;
+        }
+        if (errorCode === 500 || isGenericNetworkError(e)) {
+            ToastNotification.addDangerMessage(fallbackOrContent);
+            return;
+        }
+        const directMessage = getDirectErrorMessage(e);
+        if (directMessage && !isGenericNetworkError(directMessage)) {
+            ToastNotification.addDangerMessage(directMessage);
+            return;
+        }
+        ToastNotification.addDangerMessage(fallbackOrContent);
+    };
+    const showFieldError = (e, fieldName, onRetry) => {
+        const field = t(fieldName);
+        showError(e, {
+            title: t('{{field}} update failed', { field }),
+            message: t('{{field}} could not be updated. Please try again or refresh the page and try once more.', {
+                field,
+            }),
+            onRetry,
         });
-        ToastNotification.addDangerMessage(errorMessage);
     };
-    return { showError };
+    return { showError, showFieldError };
 }

package/lib/esm/hooks/useResetCaseCreate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useResetCaseCreate.d.ts","sourceRoot":"","sources":["../../../src/hooks/useResetCaseCreate.tsx"],"names":[],"mappings":"AAqBA,wBAAgB,kBAAkB;;EAsCjC"}
+{"version":3,"file":"useResetCaseCreate.d.ts","sourceRoot":"","sources":["../../../src/hooks/useResetCaseCreate.tsx"],"names":[],"mappings":"AAcA,wBAAgB,kBAAkB;;EAsCjC"}

package/lib/esm/hooks/useResetCaseCreate.js

@@ -1,4 +1,3 @@
-import { fetchLoggedInUser, fetchLoggedInUsersAccount, GlobalMetadataDispatchContext, GlobalMetadataStateContext, } from '@rh-support/react-context';
 import { useContext } from 'react';
 import { AttachmentDispatchContext, resetAttachment } from '../components/shared/fileUpload';
 import { useCaseDispatch } from '../context/CaseContext';
@@ -7,7 +6,6 @@ import { useRecommendationDispatchContext } from '../context/RecommendationConte
 import { RulesDispatchContext } from '../context/RulesContext';
 import { TCDispatchContext } from '../context/TopContentContext';
 import { CaseReducerConstants } from '../reducers/CaseConstNTypes';
-import { setCaseAccountNumber, setCaseOwner } from '../reducers/CaseReducer';
 import { resetClusterRecommendations } from '../reducers/ClusterRecommendationsReducer';
 import { resetRecommendations } from '../reducers/RecommendationsReducer';
 import { resetEARules } from '../reducers/RulesReducer';
@@ -17,22 +15,31 @@ export function useResetCaseCreate() {
     const tcDispatch = useContext(TCDispatchContext);
     const recommendationsDispatch = useRecommendationDispatchContext();
     const caseDispatch = useCaseDispatch();
-    const dispatchToGlobalMetadataReducer = useContext(GlobalMetadataDispatchContext);
     const rulesDispatch = useContext(RulesDispatchContext);
     const clusterRecommendationsDispatch = useContext(ClusterRecommendationsDispatchContext);
-    const { globalMetadataState: { loggedInUsersAccount, loggedInUserRights, loggedInUserJwtToken }, } = useContext(GlobalMetadataStateContext);
     const resetCaseCreateState = () => {
-        // On case creation we refetch the user contact details to get users updated phone number
-        fetchLoggedInUser(dispatchToGlobalMetadataReducer, loggedInUserJwtToken, {});
+        // Commented out — don't refetch logged-in user contact details on case creation
+        // fetchLoggedInUser(dispatchToGlobalMetadataReducer, loggedInUserJwtToken, {});
         resetAttachment(dispatchToAttachmentReducer);
         resetTopContent(tcDispatch);
         resetRecommendations(recommendationsDispatch);
         caseDispatch({ type: CaseReducerConstants.resetCaseState });
-        // on case creation we refetch the account details to check if user still has all valid
-        // access for next case creation. For ex. may be user has exhausted his available enhanced sla limit
-        fetchLoggedInUsersAccount(dispatchToGlobalMetadataReducer, loggedInUserJwtToken, true);
-        setCaseAccountNumber(caseDispatch, loggedInUserRights.data.getAccountNumber(), true, loggedInUsersAccount.data);
-        setCaseOwner(caseDispatch, loggedInUserRights.data.getHydraContactFromLoggedInUser(), '', undefined, undefined, true);
+        // Commented out — don't refetch account details or auto-populate account/owner on case creation
+        // fetchLoggedInUsersAccount(dispatchToGlobalMetadataReducer, loggedInUserJwtToken, true, apolloClient);
+        // setCaseAccountNumber(caseDispatch, loggedInUserRights.data.getAccountNumber(), true, loggedInUsersAccount.data);
+        // setCaseOwner(
+        //     caseDispatch,
+        //     loggedInUserRights.data.getHydraContactFromLoggedInUser(),
+        //     '',
+        //     undefined,
+        //     undefined,
+        //     true,
+        // undefined,
+        // true,
+        // undefined,
+        // undefined,
+        // loggedInUserRights.data.isInternal() ? loggedInUserRights.data.getAccountNumber() : undefined
+        // );
         resetEARules(rulesDispatch);
         resetClusterRecommendations(clusterRecommendationsDispatch);
     };

package/lib/esm/hooks/useS3Upload.d.ts

@@ -1,9 +1,10 @@
-export declare function useS3Upload(idToUploadTo: any, isSecureSupport: any): {
-    uploadFile: ({ file, description, isPrivate, listenerFn }: {
-        file: any;
+import { ApolloQueryClient } from '@rh-support/utils';
+export declare function useS3Upload(caseNumber: string, apolloClient?: ApolloQueryClient, caseSalesforceId?: string): {
+    uploadFile: ({ file, description, isPrivate, listenerFn, }: {
+        file: File;
         description?: string;
         isPrivate?: boolean;
-        listenerFn?: (percent: any, abort: any) => void;
+        listenerFn?: (percent: number, abort: () => void) => void;
     }) => Promise<string>;
     isUploadingFile: boolean;
 };

package/lib/esm/hooks/useS3Upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useS3Upload.d.ts","sourceRoot":"","sources":["../../../src/hooks/useS3Upload.ts"],"names":[],"mappings":"AASA,wBAAgB,WAAW,CAAC,YAAY,KAAA,EAAE,eAAe,KAAA;;;;;;;;EA0ExD"}
+{"version":3,"file":"useS3Upload.d.ts","sourceRoot":"","sources":["../../../src/hooks/useS3Upload.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,iBAAiB,EAIpB,MAAM,mBAAmB,CAAC;AAU3B,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,iBAAiB,EAAE,gBAAgB,CAAC,EAAE,MAAM;gEA0BpG;QACC,IAAI,EAAE,IAAI,CAAC;QACX,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;KAC7D;;EAoDJ"}

package/lib/esm/hooks/useS3Upload.js

@@ -7,14 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { caseAttachments } from '@cee-eng/hydrajs';
-import { ToastNotification, useFetch } from '@rh-support/components';
+import { ToastNotification } from '@rh-support/components';
+import { useGlobalStateContext } from '@rh-support/react-context';
+import { fetchCaseDetailsByCaseNumber, pollAttachmentUploadStatus, uploadCaseAttachment, } from '@rh-support/utils';
 import { useTranslation } from 'react-i18next';
-export function useS3Upload(idToUploadTo, isSecureSupport) {
-    const { request, isFetching: isUploadingFile } = useFetch(caseAttachments.uploadAttachmentS3, {
-        propgateErrors: true,
-    });
+// TODO: Re-enable when Hydra/GraphQL attachment APIs support secure support again
+// Previously: useS3Upload(idToUploadTo, isSecureSupport) and passed isSecureSupport into uploadAttachmentS3
+export function useS3Upload(caseNumber, apolloClient, caseSalesforceId) {
     const { t } = useTranslation();
+    const { globalMetadataState: { loggedInUsersAccount }, } = useGlobalStateContext();
     const getFileAccessDetails = (file) => __awaiter(this, void 0, void 0, function* () {
         const fileName = (file === null || file === void 0 ? void 0 : file.name) || '';
         if (file.size === 0) {
@@ -23,12 +24,12 @@ export function useS3Upload(idToUploadTo, isSecureSupport) {
         const reader = new FileReader();
         return new Promise((resolve, reject) => {
             reader.onloadend = () => resolve({ ableToUpload: true, ableToUploadMessage: 'File attached, but not yet uploaded' });
-            reader.onerror = (ev) => reject({ ableToUpload: false, ableToUploadMessage: `${fileName} ${t("Can't be selected")}` });
-            // only read the first 10 bytes. readAsBinaryString is not supported in IE 11
+            reader.onerror = () => reject({ ableToUpload: false, ableToUploadMessage: `${fileName} ${t("Can't be selected")}` });
             reader.readAsArrayBuffer(file.slice(0, 10));
         });
     });
-    const uploadFile = (_a) => __awaiter(this, [_a], void 0, function* ({ file, description = '', isPrivate = false, listenerFn = (percent, abort) => { } }) {
+    const uploadFile = (_a) => __awaiter(this, [_a], void 0, function* ({ file, description = '', isPrivate = false, listenerFn = (_percent, _abort) => { }, }) {
+        var _b;
         try {
             yield getFileAccessDetails(file);
         }
@@ -38,33 +39,30 @@ export function useS3Upload(idToUploadTo, isSecureSupport) {
                 return;
             }
         }
-        const listener = (progress, abort) => {
-            const decimal = progress.loaded / progress.total;
-            const percent = decimal * 100;
-            // const verifyingUpdate = decimal === 1;
-            const currentUploadProgress = Math.floor(percent);
-            // Forwarding abort single to parent callback function
-            listenerFn(currentUploadProgress, abort);
-        };
-        const putObjectRequest = {
-            Body: file, // use the original file for upload
-            ContentLength: file.size,
-            Metadata: Object.assign(Object.assign(Object.assign(Object.assign({}, (description && { 'x-amz-meta-description': description })), (file.name && { 'x-amz-meta-fileName': file.name })), (file.size && { 'x-amz-meta-byteLength': file.size.toString() })), (file.type && { 'x-amz-meta-content-type': file.type })),
-        };
         try {
-            const attachmentId = yield request(idToUploadTo, {
-                description: description,
-                fileName: file.name,
-                isPrivate: isPrivate,
-                size: file.size,
-            }, putObjectRequest, listener, true, { partSize: 5 * 1024 * 1024, queueSize: 5 }, isSecureSupport);
+            let abortFn;
+            const attachmentId = yield uploadCaseAttachment(caseNumber, file, (percent) => listenerFn(percent, () => abortFn === null || abortFn === void 0 ? void 0 : abortFn()), (abort) => {
+                abortFn = abort;
+            }, undefined, undefined, undefined, description);
+            let resolvedCaseSalesforceId = caseSalesforceId;
+            if (apolloClient && !resolvedCaseSalesforceId) {
+                const caseDetails = yield fetchCaseDetailsByCaseNumber(apolloClient, caseNumber, Boolean((_b = loggedInUsersAccount === null || loggedInUsersAccount === void 0 ? void 0 : loggedInUsersAccount.data) === null || _b === void 0 ? void 0 : _b.secureSupport));
+                resolvedCaseSalesforceId = caseDetails === null || caseDetails === void 0 ? void 0 : caseDetails.id;
+            }
+            if (apolloClient && resolvedCaseSalesforceId) {
+                yield pollAttachmentUploadStatus(apolloClient, resolvedCaseSalesforceId, attachmentId);
+            }
             return attachmentId;
         }
         catch (error) {
             if (error.message === 'Request aborted by user') {
-                // Show alert if needed
+                return;
             }
+            throw error;
         }
     });
-    return { uploadFile, isUploadingFile };
+    return {
+        uploadFile,
+        isUploadingFile: false,
+    };
 }

package/lib/esm/hooks/useWizard.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 interface IProps {
     userSeenRecommendationsfn?: any;
     userSeenRecommendationsValue: boolean;
@@ -5,6 +6,19 @@ interface IProps {
     userClickedNextonRecommendationsValue: boolean;
     resultsRowRef: any;
     userScrolledLabel: boolean;
+    isAIChatMode: boolean;
+    setIsAIChatMode: (value: boolean) => void;
+    onChatWithAIClick?: () => void;
+    aiServicesAvailable: boolean;
+    isSecureSupport?: boolean;
+    hasConfirmedStatesideSupport?: boolean;
+    onBack?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    haveARHFieldsChanged?: boolean;
+    haveARHFieldsChangedForBRef?: React.MutableRefObject<boolean>;
+    haveNewARHFieldsChangedRef?: React.MutableRefObject<boolean>;
+    resetARHFieldsChanged?: () => void;
+    resetARHFieldsChangedForB?: () => void;
+    onSeeMoreResources?: () => void;
 }
 export declare function useWizard(routeProps: any, props?: IProps): {
     getStepsSequece: (showRest?: boolean) => any;

package/lib/esm/hooks/useWizard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWizard.d.ts","sourceRoot":"","sources":["../../../src/hooks/useWizard.tsx"],"names":[],"mappings":"AA+BA,UAAU,MAAM;IACZ,yBAAyB,CAAC,EAAE,GAAG,CAAC;IAChC,4BAA4B,EAAE,OAAO,CAAC;IACtC,6BAA6B,EAAE,OAAO,CAAC;IACvC,qCAAqC,EAAE,OAAO,CAAC;IAC/C,aAAa,EAAE,GAAG,CAAC;IACnB,iBAAiB,EAAE,OAAO,CAAC;CAC9B;AAED,wBAAgB,SAAS,CAAC,UAAU,KAAA,EAAE,KAAK,CAAC,EAAE,MAAM;iCA6Qb,OAAO;EAwC7C"}
+{"version":3,"file":"useWizard.d.ts","sourceRoot":"","sources":["../../../src/hooks/useWizard.tsx"],"names":[],"mappings":"AAKA,OAAO,KAA+B,MAAM,OAAO,CAAC;AA4BpD,UAAU,MAAM;IACZ,yBAAyB,CAAC,EAAE,GAAG,CAAC;IAChC,4BAA4B,EAAE,OAAO,CAAC;IACtC,6BAA6B,EAAE,OAAO,CAAC;IACvC,qCAAqC,EAAE,OAAO,CAAC;IAC/C,aAAa,EAAE,GAAG,CAAC;IACnB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;IAC1D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,2BAA2B,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC9D,0BAA0B,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC7D,qBAAqB,CAAC,EAAE,MAAM,IAAI,CAAC;IACnC,yBAAyB,CAAC,EAAE,MAAM,IAAI,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC;AAED,wBAAgB,SAAS,CAAC,UAAU,KAAA,EAAE,KAAK,CAAC,EAAE,MAAM;iCAgUb,OAAO;EAwC7C"}

package/lib/esm/hooks/useWizard.js

@@ -1,5 +1,6 @@
+import { Alert } from '@patternfly/react-core';
 import { AlertMessage, AlertType, LoadingIndicator } from '@rh-support/components';
-import { PreviousCaseTypes } from '@rh-support/utils';
+import { isFunctionalCookieAccepted, PreviousCaseTypes } from '@rh-support/utils';
 import isEmpty from 'lodash/isEmpty';
 import isEqual from 'lodash/isEqual';
 import React, { Suspense, useContext } from 'react';
@@ -19,7 +20,9 @@ import { RouteContext } from '../context/RouteContext';
 import { TCStateContext } from '../context/TopContentContext';
 import { AppRouteSections, openCaseNonTechnicalSequence, openCaseRouteSectionSequence, searchIntentRouteSectionSequence, troubleshootNonTechnicalSequence, troubleshootRouteSectionsSequence, } from '../reducers/RouteConstNTypes';
 import RouteUtils from '../utils/routeUtils';
+import { useAB } from './useAB';
 export function useWizard(routeProps, props) {
+    const { isVariationA } = useAB();
     const { routeState: { activeSection, isSearchIntent, isNextBtnClickedToShowValidationError }, } = useContext(RouteContext);
     // state value was available later - reading dirctly from url
     const isCaseCreate = RouteUtils.getQueryParams(routeProps).caseCreate === 'true';
@@ -35,8 +38,6 @@ export function useWizard(routeProps, props) {
     const { isSectionValidFn, isActiveSectionValid } = useIsSectionValid(activeSection);
     const isIdea = caseType === PreviousCaseTypes.FEATURE_ENHANCEMENT;
     const defaultRouteConfiguration = {
-        canJumpTo: true,
-        enableNext: false,
         nextButtonLabel: 'Continue',
     };
     const alertMessage = () => {
@@ -47,32 +48,53 @@ export function useWizard(routeProps, props) {
             : t('Please address the errors to proceed');
         return (React.createElement(AlertMessage, { show: isNextBtnClickedToShowValidationError && !isActiveSectionValid, variant: (isLoadingRecommendations && summary && issue) || topContent.isFetching
                 ? AlertType.INFO
-                : AlertType.DANGER, isInline: true, title: title, className: "pf-v5-u-mb-lg", "data-tracking-id": isLoading ? 'wait-recommendations-loading' : 'proceed-address-errors' }));
+                : AlertType.DANGER, isInline: true, title: title, className: "pf-v6-u-mb-lg hide-for-askredhat", "data-tracking-id": isLoading ? 'wait-recommendations-loading' : 'proceed-address-errors' }));
+    };
+    const aiInformationAlert = () => {
+        return (React.createElement("div", { className: "form-group" },
+            React.createElement(Alert, { variant: "info", isInline: true, isPlain: true, title: "The information you provide will be processed using AI technology to recommend solutions and facilitate a more efficient support experience. Always review AI-generated responses prior to use.", component: "span", className: "non-bold-alert" })));
     };
     let summarizeNextButtonLabelLogic = () => {
         return props.userScrolledLabel;
     };
+    const getResourcesNextButtonLabel = () => {
+        const hasNoResults = numFound === 0 && isFunctionalCookieAccepted();
+        const hasUserInteracted = ((summarizeNextButtonLabelLogic() || ((props === null || props === void 0 ? void 0 : props.userSeenRecommendationsValue) && numFound < 3)) &&
+            !isEmpty(issue)) ||
+            hasNoResults;
+        return hasUserInteracted ? (isCaseCreate ? t('Continue') : t('Convert to case')) : t('See more options');
+    };
     // components that are used in wizard steps
     const appRouteConfugurations = {
         [AppRouteSections.GET_SUPPORT]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: AppRouteSections.GET_SUPPORT, name: t('Get support'), component: (React.createElement(MainSection, { stepNumber: 1, totalSteps: 6, section: AppRouteSections.GET_SUPPORT, title: t('Why are you opening a case?'), description: t('Select the best category for your issue.') },
                 React.createElement(Suspense, { fallback: React.createElement(LoadingIndicator, { size: "sm" }) },
                     alertMessage(),
+                    isCaseCreate && !props.isSecureSupport && !props.hasConfirmedStatesideSupport
+                        ? aiInformationAlert()
+                        : null,
                     React.createElement(OpenCase, { routeProps: routeProps, userSeenRecommendations: props.userSeenRecommendationsfn, userClickedNextonRecommendations: props.userClickedNextonRecommendationsValue, resultsRowRef: props.resultsRowRef })))), canJumpTo: isSectionValidFn(AppRouteSections.GET_SUPPORT) || activeSection === AppRouteSections.GET_SUPPORT }),
         [isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT, name: isCaseCreate ? t('Summarize') : t('Troubleshoot'), component: (React.createElement(MainSection, { stepNumber: 2, totalSteps: 6, section: isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT, title: t('What are you having an issue with?') },
                 React.createElement(Suspense, { fallback: React.createElement(LoadingIndicator, { size: "sm" }) },
                     alertMessage(),
+                    !props.isSecureSupport && !props.hasConfirmedStatesideSupport && aiInformationAlert(),
                     React.createElement(ProductSelector, { routeProps: routeProps, userSeenRecommendations: props.userSeenRecommendationsfn, userClickedNextonRecommendations: props.userClickedNextonRecommendationsValue, resultsRowRef: props.resultsRowRef, isOnGetSupportPage: false, caseCreateExperience: isCaseCreate })))), canJumpTo: isSectionValidFn(isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT) ||
-                activeSection === (isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT), nextButtonLabel: ((summarizeNextButtonLabelLogic() || ((props === null || props === void 0 ? void 0 : props.userSeenRecommendationsValue) && numFound < 3)) &&
-                !isEmpty(issue)) ||
-                numFound === 0 // do this so that when user refreshes tab and state persists we don't cause edge 'continue' render
+                activeSection === (isCaseCreate ? AppRouteSections.SUMMARIZE : AppRouteSections.TROUBLESHOOT), nextButtonLabel: isVariationA
                 ? t('Continue')
-                : t('See more options') }),
+                : ((summarizeNextButtonLabelLogic() || ((props === null || props === void 0 ? void 0 : props.userSeenRecommendationsValue) && numFound < 3)) &&
+                    !isEmpty(issue)) ||
+                    numFound === 0
+                    ? t('Continue')
+                    : t('See more options') }),
         [AppRouteSections.RESOURCES]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: AppRouteSections.RESOURCES, name: isCaseCreate ? t('Resources') : t('Resources'), component: (React.createElement(MainSection, { stepNumber: 3, totalSteps: 6, section: AppRouteSections.RESOURCES, title: t('Recommendations') },
                 React.createElement(Suspense, { fallback: React.createElement(LoadingIndicator, { size: "sm" }) },
                     alertMessage(),
-                    React.createElement(TroubleshootSection, null)))), canJumpTo: isSectionValidFn(AppRouteSections.RESOURCES || activeSection === AppRouteSections.RESOURCES) &&
+                    React.createElement(TroubleshootSection, { isAIChatMode: props.isAIChatMode, setIsAIChatMode: props.setIsAIChatMode, onChatWithAIClick: props.onChatWithAIClick, aiServicesAvailable: props.aiServicesAvailable, isSecureSupport: props.isSecureSupport, hasConfirmedStatesideSupport: props.hasConfirmedStatesideSupport, onBack: props.onBack, onSeeMoreResources: props.onSeeMoreResources, routeProps: routeProps, userSeenRecommendations: props.userSeenRecommendationsfn, userClickedNextonRecommendations: props.userClickedNextonRecommendationsValue, resultsRowRef: props.resultsRowRef, haveARHFieldsChanged: props.haveARHFieldsChanged, haveARHFieldsChangedForBRef: props.haveARHFieldsChangedForBRef, haveNewARHFieldsChangedRef: props.haveNewARHFieldsChangedRef, resetARHFieldsChanged: props.resetARHFieldsChanged, resetARHFieldsChangedForB: props.resetARHFieldsChangedForB })))), canJumpTo: isSectionValidFn(AppRouteSections.RESOURCES || activeSection === AppRouteSections.RESOURCES) &&
                 (props === null || props === void 0 ? void 0 : props.userSeenRecommendationsValue) &&
-                (props === null || props === void 0 ? void 0 : props.userCanNavigateToTroubleshoot), nextButtonLabel: isCaseCreate ? t('Continue') : t('Convert to case') }),
+                (props === null || props === void 0 ? void 0 : props.userCanNavigateToTroubleshoot), nextButtonLabel: isVariationA
+                ? getResourcesNextButtonLabel()
+                : isCaseCreate
+                    ? t('Continue')
+                    : t('Convert to case') }),
         [AppRouteSections.ADDITIONAL_INFORMATION]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: AppRouteSections.ADDITIONAL_INFORMATION, name: t('Additional information'), component: (React.createElement(MainSection, { stepNumber: 4, totalSteps: 6, section: AppRouteSections.ADDITIONAL_INFORMATION, title: React.createElement(React.Fragment, null,
                     t('Case information'),
                     isEmpty(RouteUtils.seBasePath) && isSelectedAccounntSecureSupport && (React.createElement("span", { className: "secured-support" },
@@ -84,7 +106,7 @@ export function useWizard(routeProps, props) {
         [AppRouteSections.DESCRIBE_IDEA]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: AppRouteSections.DESCRIBE_IDEA, name: t('Additional Information'), component: (React.createElement(MainSection, { stepNumber: 4, totalSteps: 6, section: AppRouteSections.DESCRIBE_IDEA, title: t('Idea information'), description: t("We'll be in contact with you shortly. Look for updates on this case.") },
                 React.createElement(Suspense, { fallback: React.createElement(LoadingIndicator, { size: "sm" }) },
                     alertMessage(),
-                    React.createElement(IdeaInformation, null)))), canJumpTo: isSectionValidFn(AppRouteSections.DESCRIBE_IDEA) || activeSection === AppRouteSections.DESCRIBE_IDEA, nextButtonLabel: 'Submit', disableOtherSections: false }),
+                    React.createElement(IdeaInformation, null)))), canJumpTo: isSectionValidFn(AppRouteSections.DESCRIBE_IDEA) || activeSection === AppRouteSections.DESCRIBE_IDEA, nextButtonLabel: 'Continue', disableOtherSections: false }),
         [AppRouteSections.CONFIGURATION]: Object.assign(Object.assign({}, defaultRouteConfiguration), { id: AppRouteSections.CONFIGURATION, name: t('Configuration'), component: (React.createElement(MainSection, { stepNumber: 5, totalSteps: 6, section: AppRouteSections.CONFIGURATION, title: t('Case management'), descriptionClassName: "text-medium-grey" },
                 React.createElement(Suspense, { fallback: React.createElement(LoadingIndicator, { size: "sm" }) },
                     alertMessage(),

package/lib/esm/i18n/template-de.d.ts

@@ -137,7 +137,7 @@ declare const _default: {
     'Exporting CSV': string;
     'Could not export CSV': string;
     '4 (Low)': string;
-    '3 (Normal)': string;
+    '3 (Medium)': string;
     '2 (High)': string;
     '1 (Urgent)': string;
     'Saved for later': string;
@@ -402,7 +402,7 @@ declare const _default: {
     Summary: string;
     '* All fields are mandatory.': string;
     Private: string;
-    'Action Plan': string;
+    'Action plan': string;
     'Alternate case ID': string;
     'Assigned to': string;
     'Bookmarked searches': string;
@@ -458,7 +458,6 @@ declare const _default: {
     'No access': string;
     'Bookmark Account': string;
     'Submit request': string;
-    'Oldest to Newest': string;
     i18RequestEscalationLearnMore: string;
     'Private Notes': string;
     on: string;
@@ -534,7 +533,7 @@ declare const _default: {
     STANDARD: string;
     PREMIUM: string;
     '4 (Low) - 2 business days': string;
-    '3 (Normal) - 1 business day': string;
+    '3 (Medium) - 1 business day': string;
     '2 (High) - 4 business hours': string;
     '1 (Urgent) - 1 business hour': string;
     'Loading...': string;
@@ -799,6 +798,85 @@ declare const _default: {
     'Update info': string;
     Summarize: string;
     'Describe more': string;
+    'Newest to Oldest': string;
+    'Oldest to Newest': string;
+    Reset: string;
+    'Search for a user, action, or keyword': string;
+    'Try <reloadLink>reloading the page</reloadLink> or check back later': string;
+    'Try modifying your search query or changing the date range and try again.': string;
+    Resources: string;
+    'Upload a file for Red Hat to analyze': string;
+    'To help us provide the right guidance, upload a sosreport.': string;
+    'Describe your problem. Include specific actions and error messages.': string;
+    'How to create sosreport?': string;
+    'Articles recommended by OpenShift AI': string;
+    'Updating recommendations using OpenShift AI': string;
+    'Recommending articles using OpenShift AI': string;
+    'Exact match': string;
+    'Best match': string;
+    Match: string;
+    'Additional information': string;
+    'Support articles are matched to the product and version details you selected, not the problem details you entered.': string;
+    'convert to case': string;
+    'Please provide details about the location, device, software version, etc. where you encounter this issue': string;
+    'Describe the user or financial impact. Tell us about any legal, national, or medical urgency.': string;
+    'Describe when and how often the problem occurs, e.g., daily, after specific actions, at particular times of day, etc.': string;
+    "Describe the impact to you or the business'": string;
+    'In what environment are you experiencing this behavior?': string;
+    'How frequently does this behavior occur? Does it occur repeatedly or at certain times?': string;
+    i18nKeyPlaceHolderDetail: string;
+    'Example:': string;
+    'To expedite your case, include these details:': string;
+    Problem: string;
+    'Error Messages': string;
+    'Tips for describing your problem': string;
+    "There aren't any related tasks": string;
+    All: string;
+    Jira: string;
+    'Do you want to close this case?': string;
+    i18ConfirmResolution: string;
+    Resolution: string;
+    'Red Hat solved my issue or reviewed my request': string;
+    'The issue has been self-solved': string;
+    "I'm not experiencing the issue anymore": string;
+    'AI insights is currently unavailable, try reloading.': string;
+    'Back to resources': string;
+    'Chat with AI': string;
+    'Chat with AI to get started': string;
+    'Error while loading AI insights': string;
+    'Getting AI insights...': string;
+    'No AI response available yet.': string;
+    'No recommendations for this product': string;
+    PREVIEW: string;
+    'Read more': string;
+    'Red Hat hand picked support articles': string;
+    Reload: string;
+    'Resolve your issue now with AI insights': string;
+    'Troubleshoot with AI insights': string;
+    'Want to continue the conversation? Dive deeper with our AI assistant': string;
+    'Why did you choose this rating?': string;
+    '<strong>Thank you. Any more feedback?</strong>': string;
+    '<strong>Thank you. How can we improve?</strong>': string;
+    '<strong>Thank you</strong>': string;
+    Accurate: string;
+    'Bad response': string;
+    Confusing: string;
+    Copy: string;
+    "Didn't solve my issue": string;
+    'Easy to understand': string;
+    'Good response': string;
+    Inaccurate: string;
+    'Response copied': string;
+    'Response recorded as helpful': string;
+    'Response recorded as unhelpful': string;
+    'Solved my issue': string;
+    'We appreciate your input. <br />It helps us improve this experience.': string;
+    "This feature uses AI technology. Interactions may be used to improve Red Hat's products or services. For more information about Red Hat\u2019s privacy practices, please refer to the <a>Red Hat Privacy Statement.</a>": string;
+    '<span>Return to</span> <button>case creation</button>': string;
+    'Resolve your issues now with AI insights': string;
+    'Generate AI case summary': string;
+    'By using this feature, your support case information will be used to create an AI-generated summary of your cases. Information may not be up-to-date or without error. Always review AI generated content prior to use. We encourage you to send feedback to improve the case summary feature': string;
+    "Do not share any personal or other sensitive information in your feedback. Feedback may be used to improve Red Hat's products or services. For more information about Red Hat\u2019s privacy practices, please refer to the <a><u>Red Hat Privacy Statement.</u></a>": string;
 };
 export default _default;
 //# sourceMappingURL=template-de.d.ts.map

package/lib/esm/i18n/template-de.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-de.d.ts","sourceRoot":"","sources":["../../../src/i18n/template-de.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAs7BE"}
+{"version":3,"file":"template-de.d.ts","sourceRoot":"","sources":["../../../src/i18n/template-de.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAqhCE"}