@digital-ai/dot-components 3.22.0 → 3.23.0

package/index.esm.js

@@ -9034,7 +9034,7 @@ class DashboardsService {
    * @param sort Sort ordering to apply to the query.
    * @param filter List of filters (each filter is a separate query param, and they are OR'ed).
    *
-   * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, description, external_embedding_id, external_id, id, is_ootb_dashboard, lifecycle_state, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
+   * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, description, external_embedding_id, external_id, id, is_ootb_dashboard, lifecycle_state, modified_parent_id, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
    * * **Searchable field names**: author_fullname, categories, description, name, updated_by_fullname
    *
    * @param favorite Boolean flag to only return dashboards marked as favorites.
@@ -9111,19 +9111,24 @@ class DashboardsService {
    * Get one Dashboard definition.
    * Return a single Dashboard definition, selected by ID.
    * @param dashboardId
+   * @param viewModified Return the dashboard with modified changes if they exist for this user.
    * @returns DashboardView OK
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getDashboardsService1(dashboardId) {
+  static getDashboardsService1(dashboardId, viewModified = false) {
     return __awaiter(this, void 0, void 0, function* () {
       const result = yield request({
         method: 'GET',
         path: `/metadata/bi/dashboards/${dashboardId}`,
+        query: {
+          view_modified: viewModified
+        },
         errors: {
           400: `An unknown parameter was specified.`,
           401: `Could not resolve a valid Tenant from the provided API Token.`,
-          404: `The dashboard could not be found.`
+          404: `The dashboard could not be found.`,
+          422: `Unprocessable Entity`
         }
       });
       return result.body;
@@ -9207,6 +9212,58 @@ class DashboardsService {
       return result.body;
     });
   }
+  /**
+   * Publish modifications to a dashboard
+   * Publish modifications to a dashboard
+   * @param dashboardId
+   * @param requestBody
+   * @param isSync Sync the dashboard with BI
+   * @returns DashboardView Dashboard published.
+   * @returns Error Default error response
+   * @throws ApiError
+   */
+  static postDashboardsService1(dashboardId, requestBody, isSync = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards/${dashboardId}/publish`,
+        query: {
+          is_sync: isSync
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
+    });
+  }
+  /**
+   * Revert modifications to a dashboard
+   * Revert modifications to a dashboard
+   * @param dashboardId
+   * @returns DashboardView Dashboard changes reverted.
+   * @returns Error Default error response
+   * @throws ApiError
+   */
+  static postDashboardsService2(dashboardId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards/${dashboardId}/revert`,
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`
+        }
+      });
+      return result.body;
+    });
+  }
   /**
    * Create a copy of existing dashboard
    * Create a copy of existing dashboard
@@ -9216,7 +9273,7 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static postDashboardsService1(dashboardId, requestBody) {
+  static postDashboardsService3(dashboardId, requestBody) {
     return __awaiter(this, void 0, void 0, function* () {
       const result = yield request({
         method: 'POST',
@@ -9240,7 +9297,7 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static postDashboardsService2(dashboardId) {
+  static postDashboardsService4(dashboardId) {
     return __awaiter(this, void 0, void 0, function* () {
       const result = yield request({
         method: 'POST',
@@ -9428,15 +9485,35 @@ class HelpContentService {
 }
 
 function DotDashboardStatusPill({
-  status
+  dashboard,
+  currentUser
 }) {
-  if (status === DashboardView.lifecycle_state.DRAFT) {
+  if (dashboard.lifecycle_state === DashboardView.lifecycle_state.DRAFT) {
     return jsx(DotPill, {
       label: "Draft",
       size: "small",
       variant: "outlined",
       status: "in-progress"
     });
+  } else if (dashboard.lifecycle_state === DashboardView.lifecycle_state.PUBLISHED && dashboard.is_being_modified && currentUser) {
+    if (dashboard.modified_author_id === currentUser.id) {
+      return jsx(DotPill, {
+        label: "Edit in progress",
+        size: "small",
+        variant: "outlined",
+        status: "success"
+      });
+    } else {
+      return jsx(DotPill, {
+        label: "Published",
+        icon: jsx(DotIcon, {
+          iconId: "lock"
+        }),
+        size: "small",
+        variant: "outlined",
+        status: "success"
+      });
+    }
   } else {
     return jsx(DotPill, {
       status: "success",
@@ -9466,7 +9543,7 @@ const dashboard1 = {
   lifecycle_state: DashboardView.lifecycle_state.DRAFT,
   application_instances: [],
   categories: [],
-  bi_type: DashboardView.bi_type.SUPERSET,
+  bi_type: DashboardView.bi_type.MICROSTRATEGY,
   is_ootb_dashboard: false,
   thumbnail: '',
   external_object: {
@@ -9476,7 +9553,8 @@ const dashboard1 = {
   help_content_id: helpContent.id,
   filter_configuration: [],
   favorite: false,
-  updated_dt: '2023-11-22T06:42:07.952000+00:00'
+  updated_dt: '2023-11-22T06:42:07.952000+00:00',
+  is_being_modified: false
 };
 const dashboard2 = {
   author_fullname: 'Dashboard2 Author',
@@ -9578,6 +9656,36 @@ const dashboard4 = {
   favorite: false,
   updated_dt: '2023-11-21T04:42:07.951000+00:00'
 });
+// Dashboard with in-progress edits
+({
+  author_fullname: 'Dashboard6 Author',
+  author_id: 'id6a',
+  target_apps: ['AGILITY'],
+  external_id: '6',
+  name: 'Test dashboard 6',
+  description: '',
+  dashboard_url: 'https://test.com',
+  server_url: 'https://test.com',
+  external_embedding_id: null,
+  created_dt: '2023-11-22T06:42:07.872000+00:00',
+  id: 'id6',
+  lifecycle_state: DashboardView.lifecycle_state.PUBLISHED,
+  application_instances: [],
+  categories: [],
+  bi_type: DashboardView.bi_type.MICROSTRATEGY,
+  is_ootb_dashboard: false,
+  thumbnail: '',
+  external_object: {
+    page_count: 3
+  },
+  embed_config: {},
+  help_content_id: helpContent.id,
+  filter_configuration: [],
+  favorite: false,
+  updated_dt: '2023-11-22T06:42:07.952000+00:00',
+  is_being_modified: true,
+  modified_author_id: 'id123'
+});
 const getCategoriesMock = {
   categories: {
     AGILITY: ['Scrum Master', 'DevOps Manager', 'Release Train Engineer', 'Agility Analytics'],
@@ -9789,7 +9897,7 @@ const DotMetadataApiProvider = ({
     },
     duplicateDashboard: (dashboardId, dashboard) => {
       setAccountIdHeader(accountId);
-      return cancelablePromise(DashboardsService.postDashboardsService1(dashboardId, dashboard)).then(response => {
+      return cancelablePromise(DashboardsService.postDashboardsService3(dashboardId, dashboard)).then(response => {
         setDashboardsError(null);
         setMetadata(null);
         if (dashboards) {
@@ -9804,10 +9912,33 @@ const DotMetadataApiProvider = ({
         return null;
       });
     },
+    publishDashboardChanges: (dashboardId, dashboard, isSync) => __awaiter(void 0, void 0, void 0, function* () {
+      setAccountIdHeader(accountId);
+      return cancelablePromise(DashboardsService.postDashboardsService1(dashboardId, dashboard, isSync)).then(response => {
+        setDashboardsError(null);
+        setDashboards(orig => handleUpdateDashboard(orig, response));
+        return response;
+      }).catch(error => setDashboardsError(error));
+    }),
+    revertDashboardChanges: dashboardId => __awaiter(void 0, void 0, void 0, function* () {
+      setAccountIdHeader(accountId);
+      return cancelablePromise(DashboardsService.postDashboardsService2(dashboardId)).then(response => {
+        setDashboardsError(null);
+        setDashboards(orig => handleUpdateDashboard(orig, response));
+        return response;
+      }).catch(error => setDashboardsError(error));
+    }),
+    getDashboard: (dashboardId, viewModified) => {
+      setAccountIdHeader(accountOverrideId);
+      return cancelablePromise(viewModified === undefined ? DashboardsService.getDashboardsService1(dashboardId) : DashboardsService.getDashboardsService1(dashboardId, viewModified)).then(response => {
+        setDashboardsError(null);
+        return response;
+      }).catch(error => setDashboardsError(error));
+    },
     favoriteDashboard: (dashboardId, favoriteValue) => {
       setAccountIdHeader(accountId);
       if (favoriteValue) {
-        return cancelablePromise(DashboardsService.postDashboardsService2(dashboardId)).then(response => {
+        return cancelablePromise(DashboardsService.postDashboardsService4(dashboardId)).then(response => {
           setDashboardsError(null);
           setDashboards(orig => handleUpdateDashboard(orig, response));
           return response;
@@ -10310,7 +10441,8 @@ const DotDashboardDetailsView = ({
   onFavorite,
   open,
   yOffset = 56,
-  zIndex = 990
+  zIndex = 990,
+  currentUser
 }) => {
   var _a, _b;
   const rootClasses = useStylesWithRootClass(rootClassName$E, className);
@@ -10395,7 +10527,8 @@ const DotDashboardDetailsView = ({
             className: "dashboard-details-status",
             label: "Status",
             children: jsx(DotDashboardStatusPill, {
-              status: dashboard.lifecycle_state
+              dashboard: dashboard,
+              currentUser: currentUser ? currentUser : null
             })
           }), jsx(DashboardDetailsField, {
             className: "dashboard-details-category",
@@ -10439,9 +10572,10 @@ const DotDashboardDetails = _a => {
   var {
       dashboard,
       onClose,
-      onFavorite
+      onFavorite,
+      currentUser
     } = _a,
-    commonProps = __rest(_a, ["dashboard", "onClose", "onFavorite"]);
+    commonProps = __rest(_a, ["dashboard", "onClose", "onFavorite", "currentUser"]);
   const [_openedDashboard, _setOpenedDashboard] = useState(dashboard);
   const metadataApiContext = useDotMetadataApiContext();
   const {
@@ -10481,7 +10615,8 @@ const DotDashboardDetails = _a => {
       dashboard: openedDashboard,
       open: true,
       onFavorite: favoriteHandler,
-      onClose: closeHandler
+      onClose: closeHandler,
+      currentUser: currentUser ? currentUser : null
     }));
   }
   return null;
@@ -10575,7 +10710,14 @@ const DotInputSelect = ({
     return typeof option === 'string' ? option : option.option;
   };
   const getValue = option => {
-    return typeof option === 'string' ? option : (option === null || option === void 0 ? void 0 : option.value) || option.option;
+    if (typeof option === 'string') {
+      return option;
+    }
+    // Allow empty string as a value. This is useful when the user wants to select an empty option.
+    if ((option === null || option === void 0 ? void 0 : option.value) === '') {
+      return option.value;
+    }
+    return (option === null || option === void 0 ? void 0 : option.value) || option.option;
   };
   return jsxs("div", {
     className: className,
@@ -11136,7 +11278,8 @@ function ActivePublishMessage({
   published,
   publishing,
   onChange,
-  requiresApplication
+  requiresApplication,
+  editInProgress
 }) {
   const [selectedApp, setSelectedApp] = useState(applicationList.length > 0 ? applicationList[0] : null);
   const [selectedCategories, setSelectedCategories] = useState([]);
@@ -11220,11 +11363,11 @@ function ActivePublishMessage({
         children: ["To view your newly published dashboard in", ' ', jsxs("strong", {
           children: ["\"", selectedApp.name, "\""]
         }), ", go to the", ' ', jsx("strong", {
-          children: "'Digital.ai Analytics'"
+          children: "'Analytics'"
         }), " section and explore."]
       }) : jsxs(DotTypography, {
         children: ["To view your newly published dashboard, go to the", ' ', jsx("strong", {
-          children: "'Digital.ai Analytics'"
+          children: "'Analytics'"
         }), " section and explore."]
       })]
     });
@@ -11303,9 +11446,9 @@ function ActivePublishMessage({
         value: selectedCategories,
         filterSelectedOptions: true
       }), requiresApplication && jsxs(DotTypography, {
-        children: ["You are about to publish ", jsxs("strong", {
+        children: ["You are about to", ' ', editInProgress ? 'apply changes to ' : 'publish ', ' ', jsxs("strong", {
           children: ["\"", dashboardName, "\""]
-        }), ". Click", ' ', "the publish button to promote it to the selected instance."]
+        }), ".", editInProgress ? '  Do you want to proceed with publishing these updates?' : '  Click the publish button to promote it to the selected instance.']
       })]
     })
   });
@@ -11361,7 +11504,8 @@ function DotDashboardPublishConfirm({
   dashboardToPublish,
   dashboardToUnpublish,
   onClose,
-  onStatusChanged
+  onStatusChanged,
+  currentUser
 }) {
   const [publishing, setPublishing] = useState(null);
   const [unpublishing, setUnpublishing] = useState(null);
@@ -11376,7 +11520,8 @@ function DotDashboardPublishConfirm({
   });
   const {
     updateDashboard,
-    dashboardsError
+    dashboardsError,
+    publishDashboardChanges
   } = useDotMetadataApiContext();
   const {
     cancelablePromise
@@ -11401,20 +11546,26 @@ function DotDashboardPublishConfirm({
       setUnpublished(false);
     }
   }, [dashboardToUnpublish]);
+  const editInProgressByCurrentUser = dashboard => {
+    return currentUser && dashboard.is_being_modified && dashboard.modified_author_id === currentUser.id;
+  };
   const handlePublish = useCallback(() => {
     const patchDashboard = {
       lifecycle_state: DashboardView.lifecycle_state.PUBLISHED,
       application_instances: publishAppInstance ? [publishAppInstance.id] : [],
       categories: publishCategories
     };
-    setPublishing(cancelablePromise(updateDashboard(dashboardToPublish.id, patchDashboard).then(updatedDashboard => {
+    // If we're publishing a dashboard that is being modified by the current user, we need to use the
+    // publishDashboardChanges method to commit the changes to the published dashboard.
+    const publishMethod = editInProgressByCurrentUser(dashboardToPublish) ? publishDashboardChanges : updateDashboard;
+    setPublishing(cancelablePromise(publishMethod(dashboardToPublish.id, patchDashboard).then(updatedDashboard => {
       setPublished(true);
       onStatusChanged(updatedDashboard);
       enqueueMessage('Dashboard has been published!', 'success');
     }).catch(() => {
       setPublishing(null);
     })));
-  }, [dashboardToPublish, publishAppInstance, publishCategories, updateDashboard]);
+  }, [dashboardToPublish, publishAppInstance, publishCategories, updateDashboard, publishDashboardChanges]);
   const handleCancelPublish = useCallback(() => {
     if (publishing !== null) {
       publishing.cancel();
@@ -11448,17 +11599,26 @@ function DotDashboardPublishConfirm({
     }
     return !(requiresCategories && publishCategories.length === 0);
   }, [publishAppInstance, publishCategories, requiresApplication, requiresCategories]);
+  const getPublishButtonLabel = dashboard => {
+    if (published) {
+      return 'Got it';
+    } else if (editInProgressByCurrentUser(dashboard)) {
+      return 'Yes, publish changes';
+    } else {
+      return 'Publish';
+    }
+  };
   return jsxs(Fragment, {
     children: [dashboardToPublish !== null && jsx(DotDialog, {
       cancelButtonVisible: !published,
       closeOnSubmit: false,
       hasPrimaryAction: publishing === null || published,
       open: dashboardToPublish !== null,
-      title: "Publish to application",
+      title: editInProgressByCurrentUser(dashboardToPublish) ? 'Publish changes' : 'Publish to application',
       submitButtonProps: {
         'data-testid': 'publish-confirm-button',
         disabled: !canSubmit(),
-        label: published ? 'Got it' : 'Publish'
+        label: getPublishButtonLabel(dashboardToPublish)
       },
       onCancel: handleCancelPublish,
       onSubmit: published ? handleCancelPublish : handlePublish,
@@ -11469,7 +11629,8 @@ function DotDashboardPublishConfirm({
         published: published,
         publishing: publishing !== null,
         onChange: handlePublishChange,
-        requiresApplication: requiresApplication
+        requiresApplication: requiresApplication,
+        editInProgress: editInProgressByCurrentUser(dashboardToPublish)
       })
     }), dashboardToUnpublish !== null && jsx(DotDialog, {
       cancelButtonVisible: !unpublished,
@@ -11524,11 +11685,14 @@ const StyledDotMenu = styled(DotMenu)`
 
 function DotDashboardOptionsMenu({
   dashboard,
+  currentUser,
   isEdit = false,
   menuPlacement,
   onStartDelete,
   onStartDuplicate,
   onStartStatusChange,
+  onStartRevert,
+  onViewOriginal,
   onViewMode,
   onDetails
 }) {
@@ -11547,8 +11711,10 @@ function DotDashboardOptionsMenu({
     onViewMode(dashboard, 'edit');
   }, [dashboard, onViewMode]);
   const isDraft = dashboard.lifecycle_state === DashboardView.lifecycle_state.DRAFT;
+  const isPublished = dashboard.lifecycle_state === DashboardView.lifecycle_state.PUBLISHED;
+  const dashboardLocked = isPublished && currentUser && dashboard.is_being_modified && dashboard.modified_author_id !== currentUser.id;
   const menuItems = [];
-  if (!isEdit && onViewMode && !dashboard.is_ootb_dashboard) {
+  if (!isEdit && onViewMode && !dashboard.is_ootb_dashboard && !dashboardLocked) {
     menuItems.push({
       children: jsxs(DotLink, {
         ariaLabel: "Edit dashboard",
@@ -11623,6 +11789,62 @@ function DotDashboardOptionsMenu({
       onclick: handleDeleteClick
     });
   }
+  // If this is a published dashboard, with in-progress changes, and the user is the author of the changes,
+  // show the republish, revert, and view original options.
+  if (isEdit && isPublished && currentUser && dashboard.is_being_modified && dashboard.modified_author_id === currentUser.id) {
+    const handlePublishChangesClick = () => {
+      handleMenuClose();
+      onStartStatusChange && onStartStatusChange(dashboard, DashboardView.lifecycle_state.PUBLISHED);
+    };
+    const handleRevertChangesClick = () => {
+      handleMenuClose();
+      onStartRevert && onStartRevert(dashboard);
+    };
+    const handleViewOriginalClick = () => {
+      handleMenuClose();
+      // Move to view mode and display the original dashboard without the changes
+      onViewOriginal && onViewOriginal(dashboard);
+    };
+    menuItems.push({
+      children: jsxs(DotLink, {
+        ariaLabel: "Publish changes",
+        color: "inherit",
+        onClick: handlePublishChangesClick,
+        underline: "none",
+        children: [jsx(DotIcon, {
+          iconId: "send-airplane"
+        }), " Publish changes"]
+      }),
+      key: 'republish',
+      onclick: handlePublishChangesClick
+    });
+    menuItems.push({
+      children: jsxs(DotLink, {
+        ariaLabel: "Revert to original",
+        color: "inherit",
+        onClick: handleRevertChangesClick,
+        underline: "none",
+        children: [jsx(DotIcon, {
+          iconId: "undo"
+        }), " Revert to original"]
+      }),
+      key: 'revert',
+      onclick: handleRevertChangesClick
+    });
+    menuItems.push({
+      children: jsxs(DotLink, {
+        ariaLabel: "Open published dashboard",
+        color: "inherit",
+        onClick: handleViewOriginalClick,
+        underline: "none",
+        children: [jsx(DotIcon, {
+          iconId: "visibility-on"
+        }), " Open published dashboard"]
+      }),
+      key: 'original',
+      onclick: handleViewOriginalClick
+    });
+  }
   if (onDetails) {
     if (menuItems.length > 0) {
       menuItems.push({
@@ -11788,13 +12010,17 @@ function DotDashboardActions({
   onDeleted,
   onDuplicated,
   onToggleFullscreen,
-  onViewMode
+  onViewMode,
+  onViewOriginal,
+  onRevertChanges,
+  currentUser
 }) {
   // NOTE:  useState functions need to stay at the top of the file so that
   // they are evaluated before any context imports. If they are evaluated
   // after they can cause React state issues when rendering.
   const [dashboardToCopy, setDashboardToCopy] = useState(null);
   const [dashboardToDelete, setDashboardToDelete] = useState(null);
+  const [dashboardToRevert, setDashboardToRevert] = useState(null);
   const [dashboardToPublish, setDashboardToPublish] = useState(null);
   const [dashboardToUnpublish, setDashboardToUnpublish] = useState(null);
   const [appCategories, setAppCategories] = useState(null);
@@ -11802,7 +12028,9 @@ function DotDashboardActions({
     deleteDashboard,
     duplicateDashboard,
     getCategories,
-    setOpenedDashboardDetails
+    setOpenedDashboardDetails,
+    revertDashboardChanges,
+    getDashboard
   } = useDotMetadataApiContext();
   const {
     cancelablePromise
@@ -11819,6 +12047,8 @@ function DotDashboardActions({
     setDashboardToPublish(null);
     setDashboardToUnpublish(null);
     onStatusChanged && onStatusChanged(publishedDashboard);
+    // Move to View Mode after publishing
+    onViewMode && onViewMode(publishedDashboard, 'view');
   }, [onStatusChanged]);
   const handlePublishConfirmClose = useCallback(() => {
     setDashboardToPublish(null);
@@ -11854,9 +12084,32 @@ function DotDashboardActions({
       }
     });
   }, [dashboard, onDuplicated]);
+  const handleRevertSubmit = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+    const dashboardId = dashboardToRevert.id;
+    return cancelablePromise(revertDashboardChanges(dashboardId)).then(result => {
+      setDashboardToRevert(null);
+      onRevertChanges && onRevertChanges(result);
+      onStatusChanged && onStatusChanged(result);
+      onViewMode && onViewMode(result, 'view');
+    });
+  }), [dashboardToRevert, onRevertChanges, onStatusChanged]);
+  const handleStartViewOriginal = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+    const dashboardId = dashboard.id;
+    return cancelablePromise(getDashboard(dashboardId, false)).then(result => {
+      onStatusChanged && onStatusChanged(result);
+      onViewMode && onViewMode(result, 'view');
+      onViewOriginal && onViewOriginal(result);
+    });
+  }), [dashboard, onViewOriginal, onStatusChanged]);
   const handleStartDelete = useCallback(dashboardToDel => {
     setDashboardToDelete(dashboardToDel);
   }, []);
+  const handleStartRevert = useCallback(dashboard => {
+    setDashboardToRevert(dashboard);
+  }, []);
+  const handleRevertClose = useCallback(() => {
+    setDashboardToRevert(null);
+  }, []);
   const handleStartDuplicate = useCallback(dashboardToDupe => {
     setDashboardToCopy(dashboardToDupe);
   }, []);
@@ -11864,6 +12117,8 @@ function DotDashboardActions({
   const handleStartStatusChangeIfConfig = onStatusChanged ? handleStartStatusChange : undefined;
   const handleStartDeleteIfConfig = onDeleted ? handleStartDelete : undefined;
   const handleViewModeIfConfig = onViewMode && canEdit ? onViewMode : undefined;
+  const handleRevertChangesIfConfig = onRevertChanges ? handleStartRevert : undefined;
+  const handleViewOriginalIfConfig = onViewOriginal ? handleStartViewOriginal : undefined;
   return jsxs(StyledDashboardActions, {
     "data-testid": "dot-dashboard-actions",
     children: [jsx(DotDashboardPublishConfirm, {
@@ -11871,7 +12126,8 @@ function DotDashboardActions({
       dashboardToPublish: dashboardToPublish,
       dashboardToUnpublish: dashboardToUnpublish,
       onClose: handlePublishConfirmClose,
-      onStatusChanged: handlePublishConfirm
+      onStatusChanged: handlePublishConfirm,
+      currentUser: currentUser ? currentUser : null
     }), appCategories && dashboardToCopy && jsx(DotDashboardDialog, {
       title: "Duplicate dashboard",
       availableCategories: appCategories,
@@ -11885,6 +12141,14 @@ function DotDashboardActions({
       record: dashboardToDelete.name,
       impact: dashboardToDelete.lifecycle_state === DashboardView.lifecycle_state.PUBLISHED ? 'high' : 'medium',
       open: true
+    }), dashboardToRevert && jsx(DotImpactDialog, {
+      onCancel: handleRevertClose,
+      onSubmit: handleRevertSubmit,
+      record: dashboardToRevert.name,
+      impact: "medium",
+      action: "revert",
+      actionIcon: "undo",
+      open: true
     }), jsx(HelpButton, {
       dashboard: dashboard
     }), onFavorite && jsx(FavoriteButton, {
@@ -11894,11 +12158,14 @@ function DotDashboardActions({
       dashboard: dashboard,
       isEdit: isEdit,
       menuPlacement: "bottom-start",
+      onViewOriginal: handleViewOriginalIfConfig,
       onViewMode: handleViewModeIfConfig,
       onStartStatusChange: handleStartStatusChangeIfConfig,
       onStartDuplicate: handleStartDuplicateIfConfig,
       onStartDelete: handleStartDeleteIfConfig,
-      onDetails: () => setOpenedDashboardDetails(dashboard)
+      onStartRevert: handleRevertChangesIfConfig,
+      onDetails: () => setOpenedDashboardDetails(dashboard),
+      currentUser: currentUser ? currentUser : null
     }), onToggleFullscreen && jsx(FullscreenButton, {
       dashboard: dashboard,
       isFullscreen: isFullscreen,
@@ -11920,6 +12187,22 @@ const StyledDashboardHeader = styled(DotActionToolbar)`
     padding: ${theme.spacing(0, 2)};
   `}
 `;
+const StyledDashboardBanner = styled.div`
+  ${({
+  theme
+}) => css`
+    padding: ${theme.spacing(1, 2)};
+    align-items: stretch;
+    .MuiAlert-message {
+      flex: 5;
+    }
+    .dot-typography {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+  `}
+`;
 const StyledDashboardHeaderTitleSection = styled.div`
   ${({
   theme
@@ -11940,9 +12223,75 @@ const StyledDashboardHeaderTitleSection = styled.div`
   `}
 `;
 
+function DotDashboardBanner({
+  bannerSeverity,
+  bannerText,
+  buttonText,
+  buttonAction
+}) {
+  return jsx(StyledDashboardBanner, {
+    children: jsxs(DotAlertBanner, {
+      severity: bannerSeverity,
+      "data-testid": "dashboard-banner",
+      children: [bannerText, buttonText && jsx(DotButton, {
+        type: "outlined",
+        onClick: buttonAction,
+        "data-testid": "dashboard-banner-button",
+        children: buttonText
+      })]
+    })
+  });
+}
+function getDashboardBanner(dashboard, isEdit, onExitEditMode, onPublishChanges, currentUser, modifiedAuthorUser) {
+  if (isEdit) {
+    if (dashboard.is_being_modified) {
+      if (dashboard.modified_author_id === currentUser.id) {
+        // We're in Edit mode for a published dashboard, and the dashboard is being modified by the current user.
+        return jsx(DotDashboardBanner, {
+          bannerSeverity: "warning",
+          bannerText: jsx(DotTypography, {
+            children: "The Dashboard is currently in edit mode and only you can make changes. Publish the changes for other users to see."
+          }),
+          buttonText: "Publish changes",
+          buttonAction: () => {
+            onPublishChanges(dashboard);
+          }
+        });
+      }
+    } else {
+      // We're in Edit mode for a published dashboard, but there are no staged changes saved yet.
+      return jsx(DotDashboardBanner, {
+        bannerSeverity: "info",
+        bannerText: jsx(DotTypography, {
+          children: "You are currently in Edit Mode. Any changes you make will not be visible to others until you publish the updated dashboard."
+        }),
+        buttonText: "Exit edit mode",
+        buttonAction: () => {
+          onExitEditMode(dashboard);
+        }
+      });
+    }
+  } else {
+    if (currentUser && dashboard.is_being_modified && dashboard.modified_author_id !== currentUser.id && modifiedAuthorUser) {
+      // We're in View mode for a published dashboard that is being edited by someone else.
+      const bannerText = jsx(DotTypography, {
+        children: jsxs("div", {
+          children: ["This Dashboard is currently being edited by", ' ', jsxs("strong", {
+            children: [modifiedAuthorUser.given_name, " ", modifiedAuthorUser.family_name]
+          }), ". You will be able to see the updated dashboard once the changes are published."]
+        })
+      });
+      return jsx(DotDashboardBanner, {
+        bannerSeverity: "info",
+        bannerText: bannerText
+      });
+    }
+  }
+}
 function DotDashboardHeader({
   accountId,
   dashboard,
+  currentUser,
   isEdit = false,
   canEdit = false,
   isFullscreen = false,
@@ -11952,10 +12301,14 @@ function DotDashboardHeader({
   onStatusChanged,
   onDeleted,
   onDuplicated,
+  onRevertChanges,
+  onViewOriginal,
   onToggleFullscreen,
   onViewMode,
-  showStatus = false
+  showStatus = false,
+  modifiedAuthorUser = null
 }) {
+  const [dashboardToPublish, setDashboardToPublish] = useState(null);
   const {
     applications,
     applicationsError,
@@ -11966,6 +12319,18 @@ function DotDashboardHeader({
     metadataLoading,
     dashboardsError
   } = useDotMetadataApiContext();
+  const handleStartPublishChanges = useCallback(publishDashboard => {
+    setDashboardToPublish(publishDashboard);
+  }, []);
+  const handlePublishConfirmClose = useCallback(() => {
+    setDashboardToPublish(null);
+  }, []);
+  const handlePublishConfirm = useCallback(publishedDashboard => {
+    setDashboardToPublish(null);
+    onStatusChanged && onStatusChanged(publishedDashboard);
+    // Navigate to View Mode after publishing changes
+    onViewMode && onViewMode(publishedDashboard, 'view');
+  }, [onStatusChanged]);
   useEnqueueErrorMessage(!applicationsLoading && applicationsError);
   useEnqueueErrorMessage(!metadataLoading && dashboardsError);
   useEffect(() => {
@@ -11977,29 +12342,45 @@ function DotDashboardHeader({
     iconId: "back-solid",
     onClick: () => onBack(dashboard.id)
   });
-  return jsxs(StyledDashboardHeader, {
-    children: [jsxs(StyledDashboardHeaderTitleSection, {
-      children: [jsxs(DotTypography, {
-        component: "h2",
-        variant: "h2",
-        children: [backButton, dashboard === null || dashboard === void 0 ? void 0 : dashboard.name]
-      }), showStatus && jsx(DotDashboardStatusPill, {
-        status: dashboard.lifecycle_state
+  const onExitEditMode = dashboardEdit => {
+    onViewMode && onViewMode(dashboardEdit, 'view');
+  };
+  return jsxs(Fragment, {
+    children: [jsx(DotDashboardPublishConfirm, {
+      applicationList: applications,
+      dashboardToPublish: dashboardToPublish,
+      dashboardToUnpublish: null,
+      onClose: handlePublishConfirmClose,
+      onStatusChanged: handlePublishConfirm,
+      currentUser: currentUser ? currentUser : null
+    }), jsxs(StyledDashboardHeader, {
+      children: [jsxs(StyledDashboardHeaderTitleSection, {
+        children: [jsxs(DotTypography, {
+          component: "h2",
+          variant: "h2",
+          children: [backButton, dashboard === null || dashboard === void 0 ? void 0 : dashboard.name]
+        }), showStatus && dashboard && jsx(DotDashboardStatusPill, {
+          dashboard: dashboard,
+          currentUser: currentUser ? currentUser : null
+        })]
+      }), jsx(DotDashboardActions, {
+        applications: applications,
+        canEdit: canEdit,
+        dashboard: dashboard,
+        isEdit: isEdit,
+        isFullscreen: isFullscreen,
+        onClose: onClose,
+        onFavorite: onFavorite,
+        onRevertChanges: onRevertChanges,
+        onStatusChanged: onStatusChanged,
+        onDeleted: onDeleted,
+        onDuplicated: onDuplicated,
+        onToggleFullscreen: onToggleFullscreen,
+        onViewMode: onViewMode,
+        onViewOriginal: onViewOriginal,
+        currentUser: currentUser ? currentUser : null
       })]
-    }), jsx(DotDashboardActions, {
-      applications: applications,
-      canEdit: canEdit,
-      dashboard: dashboard,
-      isEdit: isEdit,
-      isFullscreen: isFullscreen,
-      onClose: onClose,
-      onFavorite: onFavorite,
-      onStatusChanged: onStatusChanged,
-      onDeleted: onDeleted,
-      onDuplicated: onDuplicated,
-      onToggleFullscreen: onToggleFullscreen,
-      onViewMode: onViewMode
-    })]
+    }), dashboard && dashboard.lifecycle_state === 'PUBLISHED' && getDashboardBanner(dashboard, isEdit, onExitEditMode, handleStartPublishChanges, currentUser ? currentUser : null, modifiedAuthorUser ? modifiedAuthorUser : null)]
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digital-ai/dot-components",
-  "version": "3.22.0",
+  "version": "3.23.0",
   "private": false,
   "license": "SEE LICENSE IN <LICENSE.md>",
   "contributors": [

package/src/lib/components/analytics/dashboard-actions/DashboardActions.d.ts

@@ -1,7 +1,8 @@
-import { ApplicationModel } from '../../core-api/openapi';
+import { ApplicationModel, UserModel } from '../../core-api/openapi';
 import { DashboardView } from '../metadata-api/openapi/';
 interface DashboardActionsCommonProps {
     canEdit?: boolean;
+    currentUser?: UserModel;
     dashboard: DashboardView;
     isEdit?: boolean;
     isFullscreen?: boolean;
@@ -9,12 +10,14 @@ interface DashboardActionsCommonProps {
     onDeleted?: (id: string, result: boolean) => void;
     onDuplicated?: (dashboard: DashboardView, isDone?: boolean) => void;
     onFavorite?: (id: string, value: boolean) => void;
+    onRevertChanges?: (dashboard: DashboardView) => void;
     onStatusChanged?: (dashboard: DashboardView) => void;
     onToggleFullscreen?: (newValue: boolean) => void;
     onViewMode?: (dashboard: DashboardView, mode: string) => void;
+    onViewOriginal?: (dashboard: DashboardView) => void;
 }
 interface DashboardActionsProps extends DashboardActionsCommonProps {
     applications: ApplicationModel[];
 }
-declare function DotDashboardActions({ applications, dashboard, isEdit, canEdit, isFullscreen, onClose, onFavorite, onStatusChanged, onDeleted, onDuplicated, onToggleFullscreen, onViewMode, }: DashboardActionsProps): import("react/jsx-runtime").JSX.Element;
-export { DashboardActionsCommonProps, DotDashboardActions };
+declare function DotDashboardActions({ applications, dashboard, isEdit, canEdit, isFullscreen, onClose, onFavorite, onStatusChanged, onDeleted, onDuplicated, onToggleFullscreen, onViewMode, onViewOriginal, onRevertChanges, currentUser, }: DashboardActionsProps): import("react/jsx-runtime").JSX.Element;
+export { DashboardActionsCommonProps, DotDashboardActions, DashboardActionsProps, };

package/src/lib/components/analytics/dashboard-actions/DashboardOptionsMenu.d.ts

@@ -1,14 +1,18 @@
 import { PopperPlacement } from '../../menu/Menu';
 import { DashboardView } from '../metadata-api/openapi';
+import { UserModel } from '../../core-api/openapi';
 interface DashboardOptionsMenuProps {
+    currentUser?: UserModel;
     dashboard: DashboardView;
     isEdit?: boolean;
     menuPlacement?: PopperPlacement;
     onDetails?: (dashboard: DashboardView) => void;
     onStartDelete?: (dashboard: DashboardView) => void;
     onStartDuplicate?: (dashboard: DashboardView) => void;
+    onStartRevert?: (dashboard: DashboardView) => void;
     onStartStatusChange?: (dashboard: DashboardView, status: DashboardView.lifecycle_state) => void;
     onViewMode?: (dashboard: DashboardView, mode: string) => void;
+    onViewOriginal?: (dashboard: DashboardView) => void;
 }
-export declare function DotDashboardOptionsMenu({ dashboard, isEdit, menuPlacement, onStartDelete, onStartDuplicate, onStartStatusChange, onViewMode, onDetails, }: DashboardOptionsMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare function DotDashboardOptionsMenu({ dashboard, currentUser, isEdit, menuPlacement, onStartDelete, onStartDuplicate, onStartStatusChange, onStartRevert, onViewOriginal, onViewMode, onDetails, }: DashboardOptionsMenuProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/src/lib/components/analytics/dashboard-actions/DashboardPublishConfirm.d.ts

@@ -1,8 +1,10 @@
-import { ApplicationModel } from '../../core-api/openapi';
+import { ApplicationModel, UserModel } from '../../core-api/openapi';
 import { DashboardView } from '../metadata-api/openapi';
 interface DashboardPublishConfirmProps {
     /** List of applications the dashboard can be published to **/
     applicationList: ApplicationModel[];
+    /** Current User, used to determine if they have in-progress edits. **/
+    currentUser?: UserModel;
     /** Dashboard to confirm publishing for **/
     dashboardToPublish: DashboardView;
     /** Dashboard to confirm unpublishing for **/
@@ -12,5 +14,5 @@ interface DashboardPublishConfirmProps {
     /** When a dashboard is updated, this function is called with the updated dashboard **/
     onStatusChanged: (updatedDashboard: DashboardView) => void;
 }
-export declare function DotDashboardPublishConfirm({ applicationList, dashboardToPublish, dashboardToUnpublish, onClose, onStatusChanged, }: Readonly<DashboardPublishConfirmProps>): import("react/jsx-runtime").JSX.Element;
+export declare function DotDashboardPublishConfirm({ applicationList, dashboardToPublish, dashboardToUnpublish, onClose, onStatusChanged, currentUser, }: Readonly<DashboardPublishConfirmProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/src/lib/components/analytics/dashboard-details/DashboardDetails.d.ts

@@ -1,6 +1,7 @@
 import { MouseEvent } from 'react';
 import { CommonProps } from '../../CommonProps';
 import { DashboardView } from '../metadata-api/openapi';
+import { UserModel } from '../../core-api/openapi';
 interface CommonDashboardDetailsProps extends CommonProps {
     onClose?: (event: MouseEvent | KeyboardEvent) => void;
     onFavorite?: (dashboardId: string, favoriteValue: boolean) => void;
@@ -8,12 +9,14 @@ interface CommonDashboardDetailsProps extends CommonProps {
     zIndex?: number;
 }
 interface DashboardDetailsViewProps extends CommonDashboardDetailsProps {
+    currentUser?: UserModel;
     dashboard: DashboardView;
     open: boolean;
 }
-export declare const DotDashboardDetailsView: ({ className, dashboard, onClose, onFavorite, open, yOffset, zIndex, }: DashboardDetailsViewProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DotDashboardDetailsView: ({ className, dashboard, onClose, onFavorite, open, yOffset, zIndex, currentUser, }: DashboardDetailsViewProps) => import("react/jsx-runtime").JSX.Element;
 export interface DashboardDetailsProps extends CommonDashboardDetailsProps {
+    currentUser?: UserModel;
     dashboard?: DashboardView;
 }
-export declare const DotDashboardDetails: ({ dashboard, onClose, onFavorite, ...commonProps }: DashboardDetailsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DotDashboardDetails: ({ dashboard, onClose, onFavorite, currentUser, ...commonProps }: DashboardDetailsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/src/lib/components/analytics/dashboard-details/DashboardStatusPill.d.ts

@@ -1,5 +1,8 @@
+import { DashboardView } from '../metadata-api/openapi';
+import { UserModel } from '../../core-api/openapi';
 interface DashboardStatusPillProps {
-    status: string;
+    currentUser?: UserModel;
+    dashboard: DashboardView;
 }
-declare function DotDashboardStatusPill({ status, }: Readonly<DashboardStatusPillProps>): import("react/jsx-runtime").JSX.Element;
+declare function DotDashboardStatusPill({ dashboard, currentUser, }: Readonly<DashboardStatusPillProps>): import("react/jsx-runtime").JSX.Element;
 export { DashboardStatusPillProps, DotDashboardStatusPill };

package/src/lib/components/analytics/dashboard-header/DashboardHeader.d.ts

@@ -1,8 +1,10 @@
+import { UserModel } from '../../core-api/openapi';
 import { DashboardActionsCommonProps } from '../dashboard-actions/DashboardActions';
 interface DashboardHeaderProps extends DashboardActionsCommonProps {
     accountId?: string;
+    modifiedAuthorUser?: UserModel;
     onBack?: (dashboardId?: string) => void;
     showStatus?: boolean;
 }
-declare function DotDashboardHeader({ accountId, dashboard, isEdit, canEdit, isFullscreen, onBack, onClose, onFavorite, onStatusChanged, onDeleted, onDuplicated, onToggleFullscreen, onViewMode, showStatus, }: DashboardHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare function DotDashboardHeader({ accountId, dashboard, currentUser, isEdit, canEdit, isFullscreen, onBack, onClose, onFavorite, onStatusChanged, onDeleted, onDuplicated, onRevertChanges, onViewOriginal, onToggleFullscreen, onViewMode, showStatus, modifiedAuthorUser, }: DashboardHeaderProps): import("react/jsx-runtime").JSX.Element;
 export { DashboardHeaderProps, DotDashboardHeader };

package/src/lib/components/analytics/dashboard-header/DashboardHeader.styles.d.ts

@@ -1,2 +1,3 @@
 export declare const StyledDashboardHeader: import("styled-components").StyledComponent<({ ariaLabel, children, className, "data-testid": dataTestId, variant, }: import("../../action-toolbar/ActionToolbar").DotActionBarProps) => import("react/jsx-runtime").JSX.Element, any, {}, never>;
+export declare const StyledDashboardBanner: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const StyledDashboardHeaderTitleSection: import("styled-components").StyledComponent<"div", any, {}, never>;

package/src/lib/components/analytics/metadata-api/MetadataApiProvider.d.ts

@@ -14,10 +14,13 @@ interface DotMetadataApiContextProps {
     favoriteDashboard: (dashboardId: string, favoriteValue: boolean) => Promise<DashboardView>;
     getAuthors: (appType: string, publishedOnly?: boolean) => Promise<Author[]>;
     getCategories: (appType: string, publishedOnly?: boolean) => Promise<string[]>;
+    getDashboard: (dashboardId: string, viewModified?: boolean) => Promise<DashboardView>;
     getDashboardHelpContent: (helpContentId: string) => Promise<string>;
     metadataLoading: boolean;
     openedDashboardDetails: DashboardView;
     platformConsoleUrl: string;
+    publishDashboardChanges: (dashboardId: string, dashboard: DashboardPatchBody, isSync?: boolean) => Promise<DashboardView>;
+    revertDashboardChanges: (dashboardId: string) => Promise<DashboardView>;
     searchDashboards: (search: DashboardFilters) => Promise<DashboardView[]>;
     setOpenedDashboardDetails: (dashboard: DashboardView) => void;
     setOverrideAccountId: (accountId: string) => void;

package/src/lib/components/analytics/metadata-api/openapi/models/DashboardView.d.ts

@@ -99,6 +99,14 @@ export type DashboardView = {
      * Timestamp of the latest modification
      */
     updated_dt?: string | null;
+    /**
+     * Whether a published dashboard is currently being modified.
+     */
+    is_being_modified?: boolean | null;
+    /**
+     * The platform id of the author currently modifying the dashboard.
+     */
+    modified_author_id?: string | null;
 };
 export declare namespace DashboardView {
     /**

package/src/lib/components/analytics/metadata-api/openapi/services/DashboardsService.d.ts

@@ -15,7 +15,7 @@ export declare class DashboardsService {
      * @param sort Sort ordering to apply to the query.
      * @param filter List of filters (each filter is a separate query param, and they are OR'ed).
      *
-     * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, description, external_embedding_id, external_id, id, is_ootb_dashboard, lifecycle_state, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
+     * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, description, external_embedding_id, external_id, id, is_ootb_dashboard, lifecycle_state, modified_parent_id, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
      * * **Searchable field names**: author_fullname, categories, description, name, updated_by_fullname
      *
      * @param favorite Boolean flag to only return dashboards marked as favorites.
@@ -47,11 +47,12 @@ export declare class DashboardsService {
      * Get one Dashboard definition.
      * Return a single Dashboard definition, selected by ID.
      * @param dashboardId
+     * @param viewModified Return the dashboard with modified changes if they exist for this user.
      * @returns DashboardView OK
      * @returns Error Default error response
      * @throws ApiError
      */
-    static getDashboardsService1(dashboardId: string): Promise<DashboardView | Error>;
+    static getDashboardsService1(dashboardId: string, viewModified?: boolean): Promise<DashboardView | Error>;
     /**
      * Sets a single Dashboard definition.
      * Sets a Dashboard definition, selected by ID.
@@ -82,6 +83,26 @@ export declare class DashboardsService {
      * @throws ApiError
      */
     static deleteDashboardsService(dashboardId: string): Promise<Error>;
+    /**
+     * Publish modifications to a dashboard
+     * Publish modifications to a dashboard
+     * @param dashboardId
+     * @param requestBody
+     * @param isSync Sync the dashboard with BI
+     * @returns DashboardView Dashboard published.
+     * @returns Error Default error response
+     * @throws ApiError
+     */
+    static postDashboardsService1(dashboardId: string, requestBody: DashboardPatchBody, isSync?: boolean): Promise<DashboardView | Error>;
+    /**
+     * Revert modifications to a dashboard
+     * Revert modifications to a dashboard
+     * @param dashboardId
+     * @returns DashboardView Dashboard changes reverted.
+     * @returns Error Default error response
+     * @throws ApiError
+     */
+    static postDashboardsService2(dashboardId: string): Promise<DashboardView | Error>;
     /**
      * Create a copy of existing dashboard
      * Create a copy of existing dashboard
@@ -91,7 +112,7 @@ export declare class DashboardsService {
      * @returns Error Default error response
      * @throws ApiError
      */
-    static postDashboardsService1(dashboardId: string, requestBody?: DashboardCopyBody): Promise<DashboardView | Error>;
+    static postDashboardsService3(dashboardId: string, requestBody?: DashboardCopyBody): Promise<DashboardView | Error>;
     /**
      * Favorite a dashboard
      * Favorite a dashboard
@@ -100,7 +121,7 @@ export declare class DashboardsService {
      * @returns Error Default error response
      * @throws ApiError
      */
-    static postDashboardsService2(dashboardId: string): Promise<DashboardView | Error>;
+    static postDashboardsService4(dashboardId: string): Promise<DashboardView | Error>;
     /**
      * Un-favorite a dashboard
      * Un-favorite a dashboard

package/src/lib/components/core-api/openapi/index.d.ts

@@ -10,3 +10,4 @@ export type { ApplicationModelWrapper } from './models/ApplicationModelWrapper';
 export type { PaginationModel } from './models/PaginationModel';
 export { AccountsService } from './services/AccountsService';
 export { ApplicationsService } from './services/ApplicationsService';
+export type { UserModel } from './models/UserModel';

package/src/lib/components/core-api/openapi/models/UserModel.d.ts

@@ -0,0 +1,70 @@
+export type UserModel = {
+    /**
+     * UUID Account Identifier
+     */
+    account_id: string;
+    /**
+     * The user creation date in ISO format
+     */
+    created_date: string;
+    /**
+     * Email address
+     */
+    email?: string;
+    /**
+     * Whether the user is enabled or not
+     */
+    enabled: boolean;
+    /**
+     * A message when problems arise retrieving details of a user
+     */
+    readonly error?: string;
+    /**
+     * A numerical code when problems occur retrieving details of a user
+     */
+    readonly error_code?: number;
+    /**
+     * User's last name
+     */
+    family_name?: string;
+    /**
+     * User's first name
+     */
+    given_name?: string;
+    /**
+     * List of Group names
+     */
+    groups?: Array<string>;
+    /**
+     * UUID User Identifier
+     */
+    id: string;
+    /**
+     * The date of the user's most recent login in ISO format
+     */
+    last_login_date: string;
+    /**
+     * Whether the user is created via API
+     */
+    readonly local: boolean;
+    /**
+     * Whether the user is locked out or not
+     */
+    readonly locked?: boolean;
+    /**
+     * The date that the user was last modified on in ISO format
+     */
+    modified_date: string;
+    /**
+     * Whether the user is invited and not yet logged in
+     */
+    pending: boolean;
+    /**
+     * List of Role names
+     */
+    roles?: Array<string>;
+    /**
+     * Username
+     */
+    username: string;
+};