export function redirect(router: IRouter, warn = false): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });

    return dialog.launch().then(result => {
      dialog.dispose();

      if (result.value) {
        const url = `workspaces/${result.value}`;

        // Navigate to a new workspace URL and abandon this session altogether.
        router.navigate(url, { hard: true, silent: true });

        // This promise will never resolve because the application navigates
        // away to a new location. It only exists to satisfy the return type
        // of the `redirect` function.
        return new Promise<void>(() => {
          /* no-op */
        });
      }

      return redirect(router, true);
    });
  }

 return context.listCheckpoints().then(checkpoints => {
   if (checkpoints.length < 1) {
     return;
   }
   const lastCheckpoint = checkpoints[checkpoints.length - 1];
   if (!lastCheckpoint) {
     return;
   }
   const type = fileType(shell.currentWidget, docManager);
   return showDialog({
     title: `Revert ${type} to checkpoint`,
     body: new RevertConfirmWidget(lastCheckpoint, type),
     buttons: [
       Dialog.cancelButton(),
       Dialog.warnButton({ label: 'Revert' })
     ]
   }).then(result => {
     if (context.isDisposed) {
       return;
     }
     if (result.button.accept) {
       if (context.model.readOnly) {
         return context.revert();
       }
       return context.restoreCheckpoint().then(() => context.revert());
     }
   });
 });

 execute: () => {
   showDialog({
     title: 'Quit confirmation',
     body: 'Please confirm you want to quit JupyterLab.',
     buttons: [Dialog.cancelButton(), Dialog.warnButton({ label: 'Quit' })]
   }).then(result => {
     if (result.button.accept) {
       let setting = ServerConnection.makeSettings();
       let apiURL = URLExt.join(setting.baseUrl, 'api/shutdown');
       ServerConnection.makeRequest(apiURL, { method: 'POST' }, setting)
         .then(result => {
           if (result.ok) {
             // Close this window if the shutdown request has been successful
             let body = document.createElement('div');
             body.innerHTML = `<p>You have shut down the Jupyter server. You can now close this tab.</p>
               <p>To use JupyterLab again, you will need to relaunch it.</p>`;
             showDialog({
               title: 'Server stopped',
               body: new Widget({ node: body }),
               buttons: []
             });
             window.close();
           } else {
             throw new ServerConnection.ResponseError(result);
           }
         })
         .catch(data => {
           throw new ServerConnection.NetworkError(data);
         });
     }
   });
 }

  export async function redirect(
    router: IRouter,
    paths: JupyterFrontEnd.IPaths,
    workspace: string,
    warn = false
  ): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });
    const result = await dialog.launch();

    dialog.dispose();
    if (!result.value) {
      return redirect(router, paths, workspace, true);
    }

    // Navigate to a new workspace URL and abandon this session altogether.
    const page = paths.urls.page;
    const workspaces = paths.urls.workspaces;
    const prefix = (workspace ? workspaces : page).length + workspace.length;
    const rest = router.current.request.substring(prefix);
    const url = URLExt.join(workspaces, result.value, rest);

    router.navigate(url, { hard: true, silent: true });

    // This promise will never resolve because the application navigates
    // away to a new location. It only exists to satisfy the return type
    // of the `redirect` function.
    return new Promise<void>(() => undefined);
  }

 return context.listCheckpoints().then(checkpoints => {
   if (checkpoints.length < 1) {
     return;
   }
   const lastCheckpoint = checkpoints[checkpoints.length - 1];
   if (!lastCheckpoint) {
     return;
   }
   return showDialog({
     title: 'Revert notebook to checkpoint',
     body: new RevertConfirmWidget(lastCheckpoint),
     buttons: [
       Dialog.cancelButton(),
       Dialog.warnButton({ label: 'Revert' })
     ]
   }).then(result => {
     if (context.isDisposed) {
       return;
     }
     if (result.button.accept) {
       if (context.model.readOnly) {
         return context.revert();
       }
       return context.restoreCheckpoint().then(() => context.revert());
     }
   });
 });

  /**
   * Allows the user to clear state if splash screen takes too long.
   */
  function recover(fn: () => void): void {
    if (dialog) {
      return;
    }

    dialog = new Dialog({
      title: 'Loading...',
      body: `The loading screen is taking a long time.
        Would you like to clear the workspace or keep waiting?`,
      buttons: [
        Dialog.cancelButton({ label: 'Keep Waiting' }),
        Dialog.warnButton({ label: 'Clear Workspace' })
      ]
    });

    dialog
      .launch()
      .then(result => {
        if (result.button.accept) {
          return fn();
        }

        dialog.dispose();
        dialog = null;

        debouncer = window.setTimeout(() => {
          recover(fn);
        }, SPLASH_RECOVER_TIMEOUT);
      })
      .catch(() => {
        /* no-op */
      });
  }

  export async function redirect(router: IRouter, warn = false): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });

    const result = await dialog.launch();

    dialog.dispose();
    if (!result.value) {
      return redirect(router, true);
    }

    // Navigate to a new workspace URL and abandon this session altogether.
    const workspaces = PageConfig.getOption('workspacesUrl');
    const url = URLExt.join(workspaces, result.value);

    router.navigate(url, { hard: true, silent: true });

    // This promise will never resolve because the application navigates
    // away to a new location. It only exists to satisfy the return type
    // of the `redirect` function.
    return new Promise<void>(() => undefined);
  }

export function renameDialog(
  manager: IDocumentManager,
  oldPath: string
): Promise<Contents.IModel | null> {
  return showDialog({
    title: 'Rename File',
    body: new RenameHandler(oldPath),
    focusNodeSelector: 'input',
    buttons: [Dialog.cancelButton(), Dialog.okButton({ label: 'RENAME' })]
  }).then(result => {
    if (!result.value) {
      return;
    }
    if (!isValidFileName(result.value)) {
      void showErrorMessage(
        'Rename Error',
        Error(
          `"${result.value}" is not a valid name for a file. ` +
            `Names must have nonzero length, ` +
            `and cannot include "/", "\\", or ":"`
        )
      );
      return null;
    }
    let basePath = PathExt.dirname(oldPath);
    let newPath = PathExt.join(basePath, result.value);
    return renameFile(manager, oldPath, newPath);
  });
}

 function trust(widget: Notebook): Promise<void> {
   if (!widget.model) {
     return Promise.resolve(void 0);
   }
   // Do nothing if already trusted.
   let cells = widget.model.cells;
   let trusted = true;
   for (let i = 0; i < cells.length; i++) {
     let cell = cells.get(i);
     if (!cell.trusted) {
       trusted = false;
     }
   }
   if (trusted) {
     return showDialog({
       body: 'Notebook is already trusted',
       buttons: [Dialog.okButton()]
     }).then(() => void 0);
   }
   return showDialog({
     body: TRUST_MESSAGE,
     title: 'Trust this notebook?',
     buttons: [Dialog.cancelButton(), Dialog.warnButton()]
   }).then(result => {
     if (result.button.accept) {
       for (let i = 0; i < cells.length; i++) {
         let cell = cells.get(i);
         cell.trusted = true;
       }
     }
   });
 }

 return builder.build().then(() => {
   return showDialog({
     title: 'Build Complete',
     body: 'Build successfully completed, reload page?',
     buttons: [Dialog.cancelButton(),
               Dialog.warnButton({ label: 'RELOAD' })]
   });
 }).then(result => {