From 7b876c05f40f40a2df7b228d77ec5d68d8a2f241 Mon Sep 17 00:00:00 2001
From: Xavier Mouligneau <189600+XavierM@users.noreply.github.com>
Date: Sat, 1 Feb 2020 08:03:51 -0500
Subject: [PATCH 1/5] fix 508 (#56520)

---
 .../components/signals/actions.tsx            | 78 ++++++++++---------
 .../routes/rules/update_rules_route.ts        |  4 +-
 2 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/x-pack/legacy/plugins/siem/public/pages/detection_engine/components/signals/actions.tsx b/x-pack/legacy/plugins/siem/public/pages/detection_engine/components/signals/actions.tsx
index a33efeda2196b..003d2baa53dbc 100644
--- a/x-pack/legacy/plugins/siem/public/pages/detection_engine/components/signals/actions.tsx
+++ b/x-pack/legacy/plugins/siem/public/pages/detection_engine/components/signals/actions.tsx
@@ -5,7 +5,7 @@
  */
 
 import dateMath from '@elastic/datemath';
-import { getOr } from 'lodash/fp';
+import { getOr, isEmpty } from 'lodash/fp';
 import moment from 'moment';
 
 import { updateSignalStatus } from '../../../../containers/detection_engine/signals/api';
@@ -78,6 +78,7 @@ export const sendSignalToTimelineAction = async ({
   ecsData,
   updateTimelineIsLoading,
 }: SendSignalToTimelineActionProps) => {
+  let openSignalInBasicTimeline = true;
   const timelineId =
     ecsData.signal?.rule?.timeline_id != null ? ecsData.signal?.rule?.timeline_id[0] : '';
 
@@ -105,52 +106,57 @@ export const sendSignalToTimelineAction = async ({
           id: timelineId,
         },
       });
-
       const timelineTemplate: TimelineResult = omitTypenameInTimeline(
         getOr({}, 'data.getOneTimeline', responseTimeline)
       );
-      const { timeline } = formatTimelineResultToModel(timelineTemplate, true);
-      const query = replaceTemplateFieldFromQuery(
-        timeline.kqlQuery?.filterQuery?.kuery?.expression ?? '',
-        ecsData
-      );
-      const filters = replaceTemplateFieldFromMatchFilters(timeline.filters ?? [], ecsData);
-      const dataProviders = replaceTemplateFieldFromDataProviders(
-        timeline.dataProviders ?? [],
-        ecsData
-      );
-      createTimeline({
-        from,
-        timeline: {
-          ...timeline,
-          dataProviders,
-          eventType: 'all',
-          filters,
-          dateRange: {
-            start: from,
-            end: to,
-          },
-          kqlQuery: {
-            filterQuery: {
-              kuery: {
+      if (!isEmpty(timelineTemplate)) {
+        openSignalInBasicTimeline = false;
+        const { timeline } = formatTimelineResultToModel(timelineTemplate, true);
+        const query = replaceTemplateFieldFromQuery(
+          timeline.kqlQuery?.filterQuery?.kuery?.expression ?? '',
+          ecsData
+        );
+        const filters = replaceTemplateFieldFromMatchFilters(timeline.filters ?? [], ecsData);
+        const dataProviders = replaceTemplateFieldFromDataProviders(
+          timeline.dataProviders ?? [],
+          ecsData
+        );
+        createTimeline({
+          from,
+          timeline: {
+            ...timeline,
+            dataProviders,
+            eventType: 'all',
+            filters,
+            dateRange: {
+              start: from,
+              end: to,
+            },
+            kqlQuery: {
+              filterQuery: {
+                kuery: {
+                  kind: timeline.kqlQuery?.filterQuery?.kuery?.kind ?? 'kuery',
+                  expression: query,
+                },
+                serializedQuery: convertKueryToElasticSearchQuery(query),
+              },
+              filterQueryDraft: {
                 kind: timeline.kqlQuery?.filterQuery?.kuery?.kind ?? 'kuery',
                 expression: query,
               },
-              serializedQuery: convertKueryToElasticSearchQuery(query),
-            },
-            filterQueryDraft: {
-              kind: timeline.kqlQuery?.filterQuery?.kuery?.kind ?? 'kuery',
-              expression: query,
             },
+            show: true,
           },
-          show: true,
-        },
-        to,
-      });
+          to,
+        });
+      }
     } catch {
+      openSignalInBasicTimeline = true;
       updateTimelineIsLoading({ id: 'timeline-1', isLoading: false });
     }
-  } else {
+  }
+
+  if (openSignalInBasicTimeline) {
     createTimeline({
       from,
       timeline: {
diff --git a/x-pack/legacy/plugins/siem/server/lib/detection_engine/routes/rules/update_rules_route.ts b/x-pack/legacy/plugins/siem/server/lib/detection_engine/routes/rules/update_rules_route.ts
index f51cea0753f1a..590307e06a26a 100644
--- a/x-pack/legacy/plugins/siem/server/lib/detection_engine/routes/rules/update_rules_route.ts
+++ b/x-pack/legacy/plugins/siem/server/lib/detection_engine/routes/rules/update_rules_route.ts
@@ -39,8 +39,8 @@ export const createUpdateRulesRoute = (server: ServerFacade): Hapi.ServerRoute =
         language,
         output_index: outputIndex,
         saved_id: savedId,
-        timeline_id: timelineId,
-        timeline_title: timelineTitle,
+        timeline_id: timelineId = null,
+        timeline_title: timelineTitle = null,
         meta,
         filters,
         rule_id: ruleId,

From 27a4fe2ef4632d743e266925d04f6eb0dac958ea Mon Sep 17 00:00:00 2001
From: Jean-Louis Leysens <jloleysens@gmail.com>
Date: Sat, 1 Feb 2020 16:38:30 +0100
Subject: [PATCH 2/5] [Console] Fix use of legacy config (#56468)

* Fix use of legacy config

* Add types for ssl
---
 .../console/server/lib/elasticsearch_proxy_config.ts      | 7 ++++---
 src/plugins/console/server/plugin.ts                      | 4 +---
 src/plugins/console/server/types.ts                       | 8 ++++++++
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/plugins/console/server/lib/elasticsearch_proxy_config.ts b/src/plugins/console/server/lib/elasticsearch_proxy_config.ts
index 901d726ac51d8..28a971794d403 100644
--- a/src/plugins/console/server/lib/elasticsearch_proxy_config.ts
+++ b/src/plugins/console/server/lib/elasticsearch_proxy_config.ts
@@ -21,9 +21,10 @@ import _ from 'lodash';
 import http from 'http';
 import https from 'https';
 import url from 'url';
-import { Duration } from 'moment';
 
-const createAgent = (legacyConfig: any) => {
+import { ESConfigForProxy } from '../types';
+
+const createAgent = (legacyConfig: ESConfigForProxy) => {
   const target = url.parse(_.head(legacyConfig.hosts));
   if (!/^https/.test(target.protocol || '')) return new http.Agent();
 
@@ -59,7 +60,7 @@ const createAgent = (legacyConfig: any) => {
   return new https.Agent(agentOptions);
 };
 
-export const getElasticsearchProxyConfig = (legacyConfig: { requestTimeout: Duration }) => {
+export const getElasticsearchProxyConfig = (legacyConfig: ESConfigForProxy) => {
   return {
     timeout: legacyConfig.requestTimeout.asMilliseconds(),
     agent: createAgent(legacyConfig),
diff --git a/src/plugins/console/server/plugin.ts b/src/plugins/console/server/plugin.ts
index c8ef84aee3b61..65647bd5acb7c 100644
--- a/src/plugins/console/server/plugin.ts
+++ b/src/plugins/console/server/plugin.ts
@@ -60,9 +60,7 @@ export class ConsoleServerPlugin implements Plugin<ConsoleSetup> {
         const legacyConfig = readLegacyEsConfig();
         return {
           ...elasticsearch,
-          hosts: legacyConfig.hosts,
-          requestHeadersWhitelist: legacyConfig.requestHeadersWhitelist,
-          customHeaders: legacyConfig.customHeaders,
+          ...legacyConfig,
         };
       },
       pathFilters: proxyPathFilters,
diff --git a/src/plugins/console/server/types.ts b/src/plugins/console/server/types.ts
index 60ce56ad39fcd..adafcd4d30526 100644
--- a/src/plugins/console/server/types.ts
+++ b/src/plugins/console/server/types.ts
@@ -31,4 +31,12 @@ export interface ESConfigForProxy {
   requestHeadersWhitelist: string[];
   customHeaders: Record<string, any>;
   requestTimeout: Duration;
+  ssl?: {
+    verificationMode: 'none' | 'certificate' | 'full';
+    certificateAuthorities: string[] | string;
+    alwaysPresentCertificate: boolean;
+    certificate?: string;
+    key?: string;
+    keyPassphrase?: string;
+  };
 }

From cc9ff6da56b1e5accc828615bbeecfbf48d0b4d8 Mon Sep 17 00:00:00 2001
From: Pierre Gayvallet <pierre.gayvallet@elastic.co>
Date: Mon, 3 Feb 2020 09:57:55 +0100
Subject: [PATCH 3/5] avoid 'app not found' flickering while awaiting for mount
 (#56483)

---
 .../application/ui/app_container.test.tsx     | 88 +++++++++++++++++++
 .../public/application/ui/app_container.tsx   | 18 ++--
 2 files changed, 98 insertions(+), 8 deletions(-)
 create mode 100644 src/core/public/application/ui/app_container.test.tsx

diff --git a/src/core/public/application/ui/app_container.test.tsx b/src/core/public/application/ui/app_container.test.tsx
new file mode 100644
index 0000000000000..a46243a2da493
--- /dev/null
+++ b/src/core/public/application/ui/app_container.test.tsx
@@ -0,0 +1,88 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import React from 'react';
+import { mount } from 'enzyme';
+
+import { AppContainer } from './app_container';
+import { Mounter, AppMountParameters, AppStatus } from '../types';
+
+describe('AppContainer', () => {
+  const appId = 'someApp';
+  const setAppLeaveHandler = jest.fn();
+
+  const flushPromises = async () => {
+    await new Promise(async resolve => {
+      setImmediate(() => resolve());
+    });
+  };
+
+  const createResolver = (): [Promise<void>, () => void] => {
+    let resolve: () => void | undefined;
+    const promise = new Promise<void>(r => {
+      resolve = r;
+    });
+    return [promise, resolve!];
+  };
+
+  const createMounter = (promise: Promise<void>): Mounter => ({
+    appBasePath: '/base-path',
+    appRoute: '/some-route',
+    unmountBeforeMounting: false,
+    mount: async ({ element }: AppMountParameters) => {
+      await promise;
+      const container = document.createElement('div');
+      container.innerHTML = 'some-content';
+      element.appendChild(container);
+      return () => container.remove();
+    },
+  });
+
+  it('should hide the "not found" page before mounting the route', async () => {
+    const [waitPromise, resolvePromise] = createResolver();
+    const mounter = createMounter(waitPromise);
+
+    const wrapper = mount(
+      <AppContainer
+        appId={appId}
+        appStatus={AppStatus.inaccessible}
+        mounter={mounter}
+        setAppLeaveHandler={setAppLeaveHandler}
+      />
+    );
+
+    expect(wrapper.text()).toContain('Application Not Found');
+
+    wrapper.setProps({
+      appId,
+      setAppLeaveHandler,
+      mounter,
+      appStatus: AppStatus.accessible,
+    });
+    wrapper.update();
+
+    expect(wrapper.text()).toEqual('');
+
+    resolvePromise();
+    await flushPromises();
+    wrapper.update();
+
+    expect(wrapper.text()).toContain('some-content');
+  });
+});
diff --git a/src/core/public/application/ui/app_container.tsx b/src/core/public/application/ui/app_container.tsx
index 66c837d238276..885157843e7df 100644
--- a/src/core/public/application/ui/app_container.tsx
+++ b/src/core/public/application/ui/app_container.tsx
@@ -53,25 +53,27 @@ export const AppContainer: FunctionComponent<Props> = ({
         unmountRef.current = null;
       }
     };
-    const mount = async () => {
-      if (!mounter || appStatus !== AppStatus.accessible) {
-        return setAppNotFound(true);
-      }
 
-      if (mounter.unmountBeforeMounting) {
-        unmount();
-      }
+    if (!mounter || appStatus !== AppStatus.accessible) {
+      return setAppNotFound(true);
+    }
+    setAppNotFound(false);
 
+    if (mounter.unmountBeforeMounting) {
+      unmount();
+    }
+
+    const mount = async () => {
       unmountRef.current =
         (await mounter.mount({
           appBasePath: mounter.appBasePath,
           element: elementRef.current!,
           onAppLeave: handler => setAppLeaveHandler(appId, handler),
         })) || null;
-      setAppNotFound(false);
     };
 
     mount();
+
     return unmount;
   }, [appId, appStatus, mounter, setAppLeaveHandler]);
 

From fe86a86d14718ab510d60ecb1c091fefb83d3695 Mon Sep 17 00:00:00 2001
From: Gidi Meir Morris <github@gidi.io>
Date: Mon, 3 Feb 2020 11:02:29 +0000
Subject: [PATCH 4/5] adds the AlertDetails page (#55671)

This PR adds an Alerts Details page, linked from the Alerts List.

It includes:
Header containing details about the Alert.
Quick Enable / Mute buttons for the Alert
Disabled buttons to the _Edit Alert+ flyout (waiting on #51545), View in App (waiting on #56298) and Activity Log (waiting on #51548)
---
 .../np_ready/public/application/app.tsx       |  10 +-
 .../public/application/constants/index.ts     |   1 +
 .../lib/action_connector_api.test.ts          |   1 +
 .../public/application/lib/alert_api.test.ts  | 101 ++++
 .../public/application/lib/alert_api.ts       |  40 +-
 .../application/lib/value_validators.test.ts  |  77 +++
 .../application/lib/value_validators.ts       |  33 ++
 .../action_connector_form.test.tsx            |   6 +-
 .../action_type_menu.test.tsx                 |   4 +-
 .../connector_add_flyout.test.tsx             |   4 +-
 .../connector_edit_flyout.test.tsx            |   2 +-
 .../components/alert_details.test.tsx         | 519 ++++++++++++++++++
 .../components/alert_details.tsx              | 176 ++++++
 .../components/alert_details_route.test.tsx   | 409 ++++++++++++++
 .../components/alert_details_route.tsx        | 118 ++++
 .../components/alerts_list.test.tsx           |   9 +-
 .../alerts_list/components/alerts_list.tsx    |  45 +-
 .../components/collapsed_item_actions.tsx     |  32 +-
 .../components/alert_quick_edit_buttons.tsx}  | 189 +++----
 .../components/bulk_operation_popover.tsx     |  42 ++
 .../with_actions_api_operations.test.tsx      |  51 ++
 .../with_actions_api_operations.tsx           |  28 +
 .../with_bulk_alert_api_operations.test.tsx   | 269 +++++++++
 .../with_bulk_alert_api_operations.tsx        | 103 ++++
 .../np_ready/public/types.ts                  |  12 +-
 .../apps/triggers_actions_ui/details.ts       | 146 +++++
 .../apps/triggers_actions_ui/home_page.ts     |  38 ++
 .../apps/triggers_actions_ui/index.ts         |   1 +
 .../fixtures/plugins/alerts/index.ts          |  43 +-
 .../page_objects/alert_details.ts             |  26 +
 .../page_objects/index.ts                     |   2 +
 .../page_objects/triggers_actions_ui_page.ts  |   4 +
 .../services/alerting/actions.ts              |  48 ++
 .../services/alerting/alerts.ts               |  79 +++
 .../services/alerting/index.ts                |  22 +
 .../functional_with_es_ssl/services/index.ts  |   2 +
 36 files changed, 2527 insertions(+), 165 deletions(-)
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.test.ts
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.ts
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.test.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.test.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.tsx
 rename x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/{alerts_list/components/bulk_action_popover.tsx => common/components/alert_quick_edit_buttons.tsx} (52%)
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/bulk_operation_popover.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.test.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.test.tsx
 create mode 100644 x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.tsx
 create mode 100644 x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/details.ts
 create mode 100644 x-pack/test/functional_with_es_ssl/page_objects/alert_details.ts
 create mode 100644 x-pack/test/functional_with_es_ssl/services/alerting/actions.ts
 create mode 100644 x-pack/test/functional_with_es_ssl/services/alerting/alerts.ts
 create mode 100644 x-pack/test/functional_with_es_ssl/services/alerting/index.ts

diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/app.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/app.tsx
index 57e6fc4a9e18b..7d9a963c9c6b3 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/app.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/app.tsx
@@ -13,12 +13,13 @@ import {
   IUiSettingsClient,
   ApplicationStart,
 } from 'kibana/public';
-import { BASE_PATH, Section } from './constants';
+import { BASE_PATH, Section, routeToAlertDetails } from './constants';
 import { TriggersActionsUIHome } from './home';
 import { AppContextProvider, useAppDependencies } from './app_context';
 import { hasShowAlertsCapability } from './lib/capabilities';
 import { LegacyDependencies, ActionTypeModel, AlertTypeModel } from '../types';
 import { TypeRegistry } from './type_registry';
+import { AlertDetailsRouteWithApi as AlertDetailsRoute } from './sections/alert_details/components/alert_details_route';
 
 export interface AppDeps {
   chrome: ChromeStart;
@@ -53,11 +54,8 @@ export const AppWithoutRouter = ({ sectionsRegex }: any) => {
   const DEFAULT_SECTION: Section = canShowAlerts ? 'alerts' : 'connectors';
   return (
     <Switch>
-      <Route
-        exact
-        path={`${BASE_PATH}/:section(${sectionsRegex})`}
-        component={TriggersActionsUIHome}
-      />
+      <Route path={`${BASE_PATH}/:section(${sectionsRegex})`} component={TriggersActionsUIHome} />
+      {canShowAlerts && <Route path={routeToAlertDetails} component={AlertDetailsRoute} />}
       <Redirect from={`${BASE_PATH}`} to={`${BASE_PATH}/${DEFAULT_SECTION}`} />
     </Switch>
   );
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/constants/index.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/constants/index.ts
index a8364ffe21019..11b094dea0e62 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/constants/index.ts
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/constants/index.ts
@@ -13,6 +13,7 @@ export type Section = 'connectors' | 'alerts';
 export const routeToHome = `${BASE_PATH}`;
 export const routeToConnectors = `${BASE_PATH}/connectors`;
 export const routeToAlerts = `${BASE_PATH}/alerts`;
+export const routeToAlertDetails = `${BASE_PATH}/alert/:alertId`;
 
 export { TIME_UNITS } from './time_units';
 export enum SORT_ORDERS {
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/action_connector_api.test.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/action_connector_api.test.ts
index bc2949917edea..00a55bb2588bb 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/action_connector_api.test.ts
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/action_connector_api.test.ts
@@ -24,6 +24,7 @@ describe('loadActionTypes', () => {
       {
         id: 'test',
         name: 'Test',
+        enabled: true,
       },
     ];
     http.get.mockResolvedValueOnce(resolvedValue);
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.test.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.test.ts
index 0106970cf9c38..35d1a095188de 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.test.ts
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.test.ts
@@ -8,15 +8,22 @@ import { Alert, AlertType } from '../../types';
 import { httpServiceMock } from '../../../../../../../../src/core/public/mocks';
 import {
   createAlert,
+  deleteAlert,
   deleteAlerts,
   disableAlerts,
   enableAlerts,
+  disableAlert,
+  enableAlert,
+  loadAlert,
   loadAlerts,
   loadAlertTypes,
   muteAlerts,
   unmuteAlerts,
+  muteAlert,
+  unmuteAlert,
   updateAlert,
 } from './alert_api';
+import uuid from 'uuid';
 
 const http = httpServiceMock.createStartContract();
 
@@ -42,6 +49,31 @@ describe('loadAlertTypes', () => {
   });
 });
 
+describe('loadAlert', () => {
+  test('should call get API with base parameters', async () => {
+    const alertId = uuid.v4();
+    const resolvedValue = {
+      id: alertId,
+      name: 'name',
+      tags: [],
+      enabled: true,
+      alertTypeId: '.noop',
+      schedule: { interval: '1s' },
+      actions: [],
+      params: {},
+      createdBy: null,
+      updatedBy: null,
+      throttle: null,
+      muteAll: false,
+      mutedInstanceIds: [],
+    };
+    http.get.mockResolvedValueOnce(resolvedValue);
+
+    expect(await loadAlert({ http, alertId })).toEqual(resolvedValue);
+    expect(http.get).toHaveBeenCalledWith(`/api/alert/${alertId}`);
+  });
+});
+
 describe('loadAlerts', () => {
   test('should call find API with base parameters', async () => {
     const resolvedValue = {
@@ -230,6 +262,19 @@ describe('loadAlerts', () => {
   });
 });
 
+describe('deleteAlert', () => {
+  test('should call delete API for alert', async () => {
+    const id = '1';
+    const result = await deleteAlert({ http, id });
+    expect(result).toEqual(undefined);
+    expect(http.delete.mock.calls[0]).toMatchInlineSnapshot(`
+      Array [
+        "/api/alert/1",
+      ]
+    `);
+  });
+});
+
 describe('deleteAlerts', () => {
   test('should call delete API for each alert', async () => {
     const ids = ['1', '2', '3'];
@@ -335,6 +380,62 @@ describe('updateAlert', () => {
   });
 });
 
+describe('enableAlert', () => {
+  test('should call enable alert API', async () => {
+    const result = await enableAlert({ http, id: '1' });
+    expect(result).toEqual(undefined);
+    expect(http.post.mock.calls).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          "/api/alert/1/_enable",
+        ],
+      ]
+    `);
+  });
+});
+
+describe('disableAlert', () => {
+  test('should call disable alert API', async () => {
+    const result = await disableAlert({ http, id: '1' });
+    expect(result).toEqual(undefined);
+    expect(http.post.mock.calls).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          "/api/alert/1/_disable",
+        ],
+      ]
+    `);
+  });
+});
+
+describe('muteAlert', () => {
+  test('should call mute alert API', async () => {
+    const result = await muteAlert({ http, id: '1' });
+    expect(result).toEqual(undefined);
+    expect(http.post.mock.calls).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          "/api/alert/1/_mute_all",
+        ],
+      ]
+    `);
+  });
+});
+
+describe('unmuteAlert', () => {
+  test('should call unmute alert API', async () => {
+    const result = await unmuteAlert({ http, id: '1' });
+    expect(result).toEqual(undefined);
+    expect(http.post.mock.calls).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          "/api/alert/1/_unmute_all",
+        ],
+      ]
+    `);
+  });
+});
+
 describe('enableAlerts', () => {
   test('should call enable alert API per alert', async () => {
     const ids = ['1', '2', '3'];
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.ts
index 0b4f5731c1315..acc318bd5fbea 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.ts
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/alert_api.ts
@@ -12,6 +12,16 @@ export async function loadAlertTypes({ http }: { http: HttpSetup }): Promise<Ale
   return await http.get(`${BASE_ALERT_API_PATH}/types`);
 }
 
+export async function loadAlert({
+  http,
+  alertId,
+}: {
+  http: HttpSetup;
+  alertId: string;
+}): Promise<Alert> {
+  return await http.get(`${BASE_ALERT_API_PATH}/${alertId}`);
+}
+
 export async function loadAlerts({
   http,
   page,
@@ -55,6 +65,10 @@ export async function loadAlerts({
   });
 }
 
+export async function deleteAlert({ id, http }: { id: string; http: HttpSetup }): Promise<void> {
+  await http.delete(`${BASE_ALERT_API_PATH}/${id}`);
+}
+
 export async function deleteAlerts({
   ids,
   http,
@@ -62,7 +76,7 @@ export async function deleteAlerts({
   ids: string[];
   http: HttpSetup;
 }): Promise<void> {
-  await Promise.all(ids.map(id => http.delete(`${BASE_ALERT_API_PATH}/${id}`)));
+  await Promise.all(ids.map(id => deleteAlert({ http, id })));
 }
 
 export async function createAlert({
@@ -91,6 +105,10 @@ export async function updateAlert({
   });
 }
 
+export async function enableAlert({ id, http }: { id: string; http: HttpSetup }): Promise<void> {
+  await http.post(`${BASE_ALERT_API_PATH}/${id}/_enable`);
+}
+
 export async function enableAlerts({
   ids,
   http,
@@ -98,7 +116,11 @@ export async function enableAlerts({
   ids: string[];
   http: HttpSetup;
 }): Promise<void> {
-  await Promise.all(ids.map(id => http.post(`${BASE_ALERT_API_PATH}/${id}/_enable`)));
+  await Promise.all(ids.map(id => enableAlert({ id, http })));
+}
+
+export async function disableAlert({ id, http }: { id: string; http: HttpSetup }): Promise<void> {
+  await http.post(`${BASE_ALERT_API_PATH}/${id}/_disable`);
 }
 
 export async function disableAlerts({
@@ -108,11 +130,19 @@ export async function disableAlerts({
   ids: string[];
   http: HttpSetup;
 }): Promise<void> {
-  await Promise.all(ids.map(id => http.post(`${BASE_ALERT_API_PATH}/${id}/_disable`)));
+  await Promise.all(ids.map(id => disableAlert({ id, http })));
+}
+
+export async function muteAlert({ id, http }: { id: string; http: HttpSetup }): Promise<void> {
+  await http.post(`${BASE_ALERT_API_PATH}/${id}/_mute_all`);
 }
 
 export async function muteAlerts({ ids, http }: { ids: string[]; http: HttpSetup }): Promise<void> {
-  await Promise.all(ids.map(id => http.post(`${BASE_ALERT_API_PATH}/${id}/_mute_all`)));
+  await Promise.all(ids.map(id => muteAlert({ http, id })));
+}
+
+export async function unmuteAlert({ id, http }: { id: string; http: HttpSetup }): Promise<void> {
+  await http.post(`${BASE_ALERT_API_PATH}/${id}/_unmute_all`);
 }
 
 export async function unmuteAlerts({
@@ -122,5 +152,5 @@ export async function unmuteAlerts({
   ids: string[];
   http: HttpSetup;
 }): Promise<void> {
-  await Promise.all(ids.map(id => http.post(`${BASE_ALERT_API_PATH}/${id}/_unmute_all`)));
+  await Promise.all(ids.map(id => unmuteAlert({ id, http })));
 }
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.test.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.test.ts
new file mode 100644
index 0000000000000..90f575d9391b3
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.test.ts
@@ -0,0 +1,77 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import { throwIfAbsent, throwIfIsntContained } from './value_validators';
+import uuid from 'uuid';
+
+describe('throwIfAbsent', () => {
+  test('throws if value is absent', () => {
+    [undefined, null].forEach(val => {
+      expect(() => {
+        throwIfAbsent('OMG no value')(val);
+      }).toThrowErrorMatchingInlineSnapshot(`"OMG no value"`);
+    });
+  });
+
+  test('doesnt throws if value is present but falsey', () => {
+    [false, ''].forEach(val => {
+      expect(throwIfAbsent('OMG no value')(val)).toEqual(val);
+    });
+  });
+
+  test('doesnt throw if value is present', () => {
+    expect(throwIfAbsent('OMG no value')({})).toEqual({});
+  });
+});
+
+describe('throwIfIsntContained', () => {
+  test('throws if value is absent', () => {
+    expect(() => {
+      throwIfIsntContained<string>(new Set([uuid.v4()]), 'OMG no value', val => val)([uuid.v4()]);
+    }).toThrowErrorMatchingInlineSnapshot(`"OMG no value"`);
+  });
+
+  test('throws if value is absent using custom message', () => {
+    const id = uuid.v4();
+    expect(() => {
+      throwIfIsntContained<string>(
+        new Set([id]),
+        (value: string) => `OMG no ${value}`,
+        val => val
+      )([uuid.v4()]);
+    }).toThrow(`OMG no ${id}`);
+  });
+
+  test('returns values if value is present', () => {
+    const id = uuid.v4();
+    const values = [uuid.v4(), uuid.v4(), id, uuid.v4()];
+    expect(throwIfIsntContained<string>(new Set([id]), 'OMG no value', val => val)(values)).toEqual(
+      values
+    );
+  });
+
+  test('returns values if multiple values is present', () => {
+    const [firstId, secondId] = [uuid.v4(), uuid.v4()];
+    const values = [uuid.v4(), uuid.v4(), secondId, uuid.v4(), firstId];
+    expect(
+      throwIfIsntContained<string>(new Set([firstId, secondId]), 'OMG no value', val => val)(values)
+    ).toEqual(values);
+  });
+
+  test('allows a custom value extractor', () => {
+    const [firstId, secondId] = [uuid.v4(), uuid.v4()];
+    const values = [
+      { id: firstId, some: 'prop' },
+      { id: secondId, someOther: 'prop' },
+    ];
+    expect(
+      throwIfIsntContained<{ id: string }>(
+        new Set([firstId, secondId]),
+        'OMG no value',
+        (val: { id: string }) => val.id
+      )(values)
+    ).toEqual(values);
+  });
+});
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.ts
new file mode 100644
index 0000000000000..7ee7359086406
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/lib/value_validators.ts
@@ -0,0 +1,33 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { constant } from 'lodash';
+
+export function throwIfAbsent<T>(message: string) {
+  return (value: T | undefined): T => {
+    if (value === undefined || value === null) {
+      throw new Error(message);
+    }
+    return value;
+  };
+}
+
+export function throwIfIsntContained<T>(
+  requiredValues: Set<string>,
+  message: string | ((requiredValue: string) => string),
+  valueExtractor: (value: T) => string
+) {
+  const toError = typeof message === 'function' ? message : constant(message);
+  return (values: T[]) => {
+    const availableValues = new Set(values.map(valueExtractor));
+    for (const value of requiredValues.values()) {
+      if (!availableValues.has(value)) {
+        throw new Error(toError(value));
+      }
+    }
+    return values;
+  };
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_connector_form.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_connector_form.test.tsx
index 6896ac954bb06..f27f7d8c3054d 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_connector_form.test.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_connector_form.test.tsx
@@ -82,7 +82,11 @@ describe('action_connector_form', () => {
               editFlyoutVisible: false,
               setEditFlyoutVisibility: () => {},
               actionTypesIndex: {
-                'my-action-type': { id: 'my-action-type', name: 'my-action-type-name' },
+                'my-action-type': {
+                  id: 'my-action-type',
+                  name: 'my-action-type-name',
+                  enabled: true,
+                },
               },
               reloadConnectors: () => {
                 return new Promise<void>(() => {});
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_type_menu.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_type_menu.test.tsx
index 6ef2f62315d9a..6d98a5e3d120f 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_type_menu.test.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/action_type_menu.test.tsx
@@ -75,8 +75,8 @@ describe('connector_add_flyout', () => {
             editFlyoutVisible: false,
             setEditFlyoutVisibility: state => {},
             actionTypesIndex: {
-              'first-action-type': { id: 'first-action-type', name: 'first' },
-              'second-action-type': { id: 'second-action-type', name: 'second' },
+              'first-action-type': { id: 'first-action-type', name: 'first', enabled: true },
+              'second-action-type': { id: 'second-action-type', name: 'second', enabled: true },
             },
             reloadConnectors: () => {
               return new Promise<void>(() => {});
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_add_flyout.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_add_flyout.test.tsx
index 71ba52f047d61..a03296c7c3679 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_add_flyout.test.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_add_flyout.test.tsx
@@ -58,7 +58,9 @@ describe('connector_add_flyout', () => {
               setAddFlyoutVisibility: state => {},
               editFlyoutVisible: false,
               setEditFlyoutVisibility: state => {},
-              actionTypesIndex: { 'my-action-type': { id: 'my-action-type', name: 'test' } },
+              actionTypesIndex: {
+                'my-action-type': { id: 'my-action-type', name: 'test', enabled: true },
+              },
               reloadConnectors: () => {
                 return new Promise<void>(() => {});
               },
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_edit_flyout.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_edit_flyout.test.tsx
index 57e950a98eb2a..0dc38523bfab8 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_edit_flyout.test.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/action_connector_form/connector_edit_flyout.test.tsx
@@ -84,7 +84,7 @@ describe('connector_edit_flyout', () => {
             editFlyoutVisible: true,
             setEditFlyoutVisibility: state => {},
             actionTypesIndex: {
-              'test-action-type-id': { id: 'test-action-type-id', name: 'test' },
+              'test-action-type-id': { id: 'test-action-type-id', name: 'test', enabled: true },
             },
             reloadConnectors: () => {
               return new Promise<void>(() => {});
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.test.tsx
new file mode 100644
index 0000000000000..228bceb87cad7
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.test.tsx
@@ -0,0 +1,519 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import * as React from 'react';
+import uuid from 'uuid';
+import { shallow } from 'enzyme';
+import { AlertDetails } from './alert_details';
+import { Alert, ActionType } from '../../../../types';
+import { EuiTitle, EuiBadge, EuiFlexItem, EuiButtonEmpty, EuiSwitch } from '@elastic/eui';
+import { times, random } from 'lodash';
+import { FormattedMessage } from '@kbn/i18n/react';
+
+jest.mock('../../../app_context', () => ({
+  useAppDependencies: jest.fn(() => ({
+    http: jest.fn(),
+    legacy: {
+      capabilities: {
+        get: jest.fn(() => ({})),
+      },
+    },
+  })),
+}));
+
+jest.mock('../../../lib/capabilities', () => ({
+  hasSaveAlertsCapability: jest.fn(() => true),
+}));
+
+const mockAlertApis = {
+  muteAlert: jest.fn(),
+  unmuteAlert: jest.fn(),
+  enableAlert: jest.fn(),
+  disableAlert: jest.fn(),
+};
+
+// const AlertDetails = withBulkAlertOperations(RawAlertDetails);
+describe('alert_details', () => {
+  // mock Api handlers
+
+  it('renders the alert name as a title', () => {
+    const alert = mockAlert();
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    expect(
+      shallow(
+        <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+      ).containsMatchingElement(
+        <EuiTitle size="m">
+          <h1>{alert.name}</h1>
+        </EuiTitle>
+      )
+    ).toBeTruthy();
+  });
+
+  it('renders the alert type badge', () => {
+    const alert = mockAlert();
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    expect(
+      shallow(
+        <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+      ).containsMatchingElement(<EuiBadge>{alertType.name}</EuiBadge>)
+    ).toBeTruthy();
+  });
+
+  describe('actions', () => {
+    it('renders an alert action', () => {
+      const alert = mockAlert({
+        actions: [
+          {
+            group: 'default',
+            id: uuid.v4(),
+            params: {},
+            actionTypeId: '.server-log',
+          },
+        ],
+      });
+
+      const alertType = {
+        id: '.noop',
+        name: 'No Op',
+      };
+
+      const actionTypes: ActionType[] = [
+        {
+          id: '.server-log',
+          name: 'Server log',
+          enabled: true,
+        },
+      ];
+
+      expect(
+        shallow(
+          <AlertDetails
+            alert={alert}
+            alertType={alertType}
+            actionTypes={actionTypes}
+            {...mockAlertApis}
+          />
+        ).containsMatchingElement(
+          <EuiFlexItem grow={false}>
+            <EuiBadge color="hollow">{actionTypes[0].name}</EuiBadge>
+          </EuiFlexItem>
+        )
+      ).toBeTruthy();
+    });
+
+    it('renders a counter for multiple alert action', () => {
+      const actionCount = random(1, 10);
+      const alert = mockAlert({
+        actions: [
+          {
+            group: 'default',
+            id: uuid.v4(),
+            params: {},
+            actionTypeId: '.server-log',
+          },
+          ...times(actionCount, () => ({
+            group: 'default',
+            id: uuid.v4(),
+            params: {},
+            actionTypeId: '.email',
+          })),
+        ],
+      });
+      const alertType = {
+        id: '.noop',
+        name: 'No Op',
+      };
+      const actionTypes: ActionType[] = [
+        {
+          id: '.server-log',
+          name: 'Server log',
+          enabled: true,
+        },
+        {
+          id: '.email',
+          name: 'Send email',
+          enabled: true,
+        },
+      ];
+
+      const details = shallow(
+        <AlertDetails
+          alert={alert}
+          alertType={alertType}
+          actionTypes={actionTypes}
+          {...mockAlertApis}
+        />
+      );
+
+      expect(
+        details.containsMatchingElement(
+          <EuiFlexItem grow={false}>
+            <EuiBadge color="hollow">{actionTypes[0].name}</EuiBadge>
+          </EuiFlexItem>
+        )
+      ).toBeTruthy();
+
+      expect(
+        details.containsMatchingElement(
+          <EuiFlexItem grow={false}>
+            <EuiBadge color="hollow">{`+${actionCount}`}</EuiBadge>
+          </EuiFlexItem>
+        )
+      ).toBeTruthy();
+    });
+  });
+
+  describe('links', () => {
+    it('links to the Edit flyout', () => {
+      const alert = mockAlert();
+
+      const alertType = {
+        id: '.noop',
+        name: 'No Op',
+      };
+
+      expect(
+        shallow(
+          <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+        ).containsMatchingElement(
+          <EuiButtonEmpty disabled={true} iconType="pencil">
+            <FormattedMessage
+              id="xpack.triggersActionsUI.sections.alertDetails.editAlertButtonLabel"
+              defaultMessage="Edit"
+            />
+          </EuiButtonEmpty>
+        )
+      ).toBeTruthy();
+    });
+
+    it('links to the app that created the alert', () => {
+      const alert = mockAlert();
+
+      const alertType = {
+        id: '.noop',
+        name: 'No Op',
+      };
+
+      expect(
+        shallow(
+          <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+        ).containsMatchingElement(
+          <EuiButtonEmpty disabled={true} iconType="popout">
+            <FormattedMessage
+              id="xpack.triggersActionsUI.sections.alertDetails.viewAlertInAppButtonLabel"
+              defaultMessage="View in app"
+            />
+          </EuiButtonEmpty>
+        )
+      ).toBeTruthy();
+    });
+
+    it('links to the activity log', () => {
+      const alert = mockAlert();
+
+      const alertType = {
+        id: '.noop',
+        name: 'No Op',
+      };
+
+      expect(
+        shallow(
+          <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+        ).containsMatchingElement(
+          <EuiButtonEmpty disabled={true} iconType="menuLeft">
+            <FormattedMessage
+              id="xpack.triggersActionsUI.sections.alertDetails.activityLogButtonLabel"
+              defaultMessage="Activity Log"
+            />
+          </EuiButtonEmpty>
+        )
+      ).toBeTruthy();
+    });
+  });
+});
+
+describe('enable button', () => {
+  it('should render an enable button when alert is enabled', () => {
+    const alert = mockAlert({
+      enabled: true,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableButton = shallow(
+      <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+    )
+      .find(EuiSwitch)
+      .find('[name="enable"]')
+      .first();
+
+    expect(enableButton.props()).toMatchObject({
+      checked: true,
+      disabled: false,
+    });
+  });
+
+  it('should render an enable button when alert is disabled', () => {
+    const alert = mockAlert({
+      enabled: false,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableButton = shallow(
+      <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+    )
+      .find(EuiSwitch)
+      .find('[name="enable"]')
+      .first();
+
+    expect(enableButton.props()).toMatchObject({
+      checked: false,
+      disabled: false,
+    });
+  });
+
+  it('should enable the alert when alert is disabled and button is clicked', () => {
+    const alert = mockAlert({
+      enabled: true,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const disableAlert = jest.fn();
+    const enableButton = shallow(
+      <AlertDetails
+        alert={alert}
+        alertType={alertType}
+        actionTypes={[]}
+        {...mockAlertApis}
+        disableAlert={disableAlert}
+      />
+    )
+      .find(EuiSwitch)
+      .find('[name="enable"]')
+      .first();
+
+    enableButton.simulate('click');
+    const handler = enableButton.prop('onChange');
+    expect(typeof handler).toEqual('function');
+    expect(disableAlert).toHaveBeenCalledTimes(0);
+    handler!({} as React.FormEvent);
+    expect(disableAlert).toHaveBeenCalledTimes(1);
+  });
+
+  it('should disable the alert when alert is enabled and button is clicked', () => {
+    const alert = mockAlert({
+      enabled: false,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableAlert = jest.fn();
+    const enableButton = shallow(
+      <AlertDetails
+        alert={alert}
+        alertType={alertType}
+        actionTypes={[]}
+        {...mockAlertApis}
+        enableAlert={enableAlert}
+      />
+    )
+      .find(EuiSwitch)
+      .find('[name="enable"]')
+      .first();
+
+    enableButton.simulate('click');
+    const handler = enableButton.prop('onChange');
+    expect(typeof handler).toEqual('function');
+    expect(enableAlert).toHaveBeenCalledTimes(0);
+    handler!({} as React.FormEvent);
+    expect(enableAlert).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('mute button', () => {
+  it('should render an mute button when alert is enabled', () => {
+    const alert = mockAlert({
+      enabled: true,
+      muteAll: false,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableButton = shallow(
+      <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+    )
+      .find(EuiSwitch)
+      .find('[name="mute"]')
+      .first();
+
+    expect(enableButton.props()).toMatchObject({
+      checked: false,
+      disabled: false,
+    });
+  });
+
+  it('should render an muted button when alert is muted', () => {
+    const alert = mockAlert({
+      enabled: true,
+      muteAll: true,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableButton = shallow(
+      <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+    )
+      .find(EuiSwitch)
+      .find('[name="mute"]')
+      .first();
+
+    expect(enableButton.props()).toMatchObject({
+      checked: true,
+      disabled: false,
+    });
+  });
+
+  it('should mute the alert when alert is unmuted and button is clicked', () => {
+    const alert = mockAlert({
+      enabled: true,
+      muteAll: false,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const muteAlert = jest.fn();
+    const enableButton = shallow(
+      <AlertDetails
+        alert={alert}
+        alertType={alertType}
+        actionTypes={[]}
+        {...mockAlertApis}
+        muteAlert={muteAlert}
+      />
+    )
+      .find(EuiSwitch)
+      .find('[name="mute"]')
+      .first();
+
+    enableButton.simulate('click');
+    const handler = enableButton.prop('onChange');
+    expect(typeof handler).toEqual('function');
+    expect(muteAlert).toHaveBeenCalledTimes(0);
+    handler!({} as React.FormEvent);
+    expect(muteAlert).toHaveBeenCalledTimes(1);
+  });
+
+  it('should unmute the alert when alert is muted and button is clicked', () => {
+    const alert = mockAlert({
+      enabled: true,
+      muteAll: true,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const unmuteAlert = jest.fn();
+    const enableButton = shallow(
+      <AlertDetails
+        alert={alert}
+        alertType={alertType}
+        actionTypes={[]}
+        {...mockAlertApis}
+        unmuteAlert={unmuteAlert}
+      />
+    )
+      .find(EuiSwitch)
+      .find('[name="mute"]')
+      .first();
+
+    enableButton.simulate('click');
+    const handler = enableButton.prop('onChange');
+    expect(typeof handler).toEqual('function');
+    expect(unmuteAlert).toHaveBeenCalledTimes(0);
+    handler!({} as React.FormEvent);
+    expect(unmuteAlert).toHaveBeenCalledTimes(1);
+  });
+
+  it('should disabled mute button when alert is disabled', () => {
+    const alert = mockAlert({
+      enabled: false,
+      muteAll: false,
+    });
+
+    const alertType = {
+      id: '.noop',
+      name: 'No Op',
+    };
+
+    const enableButton = shallow(
+      <AlertDetails alert={alert} alertType={alertType} actionTypes={[]} {...mockAlertApis} />
+    )
+      .find(EuiSwitch)
+      .find('[name="mute"]')
+      .first();
+
+    expect(enableButton.props()).toMatchObject({
+      checked: false,
+      disabled: true,
+    });
+  });
+});
+
+function mockAlert(overloads: Partial<Alert> = {}): Alert {
+  return {
+    id: uuid.v4(),
+    enabled: true,
+    name: `alert-${uuid.v4()}`,
+    tags: [],
+    alertTypeId: '.noop',
+    consumer: 'consumer',
+    schedule: { interval: '1m' },
+    actions: [],
+    params: {},
+    createdBy: null,
+    updatedBy: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    apiKeyOwner: null,
+    throttle: null,
+    muteAll: false,
+    mutedInstanceIds: [],
+    ...overloads,
+  };
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.tsx
new file mode 100644
index 0000000000000..ffdf846efd49d
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details.tsx
@@ -0,0 +1,176 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import React, { useState } from 'react';
+import { indexBy } from 'lodash';
+import {
+  EuiPageBody,
+  EuiPageContent,
+  EuiPageContentHeader,
+  EuiPageContentHeaderSection,
+  EuiTitle,
+  EuiFlexGroup,
+  EuiFlexItem,
+  EuiBadge,
+  EuiPage,
+  EuiPageContentBody,
+  EuiButtonEmpty,
+  EuiSwitch,
+} from '@elastic/eui';
+import { FormattedMessage } from '@kbn/i18n/react';
+import { useAppDependencies } from '../../../app_context';
+import { hasSaveAlertsCapability } from '../../../lib/capabilities';
+import { Alert, AlertType, ActionType } from '../../../../types';
+import {
+  ComponentOpts as BulkOperationsComponentOpts,
+  withBulkAlertOperations,
+} from '../../common/components/with_bulk_alert_api_operations';
+
+type AlertDetailsProps = {
+  alert: Alert;
+  alertType: AlertType;
+  actionTypes: ActionType[];
+} & Pick<BulkOperationsComponentOpts, 'disableAlert' | 'enableAlert' | 'unmuteAlert' | 'muteAlert'>;
+
+export const AlertDetails: React.FunctionComponent<AlertDetailsProps> = ({
+  alert,
+  alertType,
+  actionTypes,
+  disableAlert,
+  enableAlert,
+  unmuteAlert,
+  muteAlert,
+}) => {
+  const { capabilities } = useAppDependencies();
+
+  const canSave = hasSaveAlertsCapability(capabilities);
+
+  const actionTypesByTypeId = indexBy(actionTypes, 'id');
+  const [firstAction, ...otherActions] = alert.actions;
+
+  const [isEnabled, setIsEnabled] = useState<boolean>(alert.enabled);
+  const [isMuted, setIsMuted] = useState<boolean>(alert.muteAll);
+
+  return (
+    <EuiPage>
+      <EuiPageBody>
+        <EuiPageContent>
+          <EuiPageContentHeader>
+            <EuiPageContentHeaderSection>
+              <EuiTitle size="m">
+                <h1 data-test-subj="alertDetailsTitle">{alert.name}</h1>
+              </EuiTitle>
+            </EuiPageContentHeaderSection>
+            <EuiPageContentHeaderSection>
+              <EuiFlexGroup responsive={false} gutterSize="xs">
+                <EuiFlexItem grow={false}>
+                  <EuiButtonEmpty disabled={true} iconType="pencil">
+                    <FormattedMessage
+                      id="xpack.triggersActionsUI.sections.alertDetails.editAlertButtonLabel"
+                      defaultMessage="Edit"
+                    />
+                  </EuiButtonEmpty>
+                </EuiFlexItem>
+                <EuiFlexItem grow={false}>
+                  <EuiButtonEmpty disabled={true} iconType="popout">
+                    <FormattedMessage
+                      id="xpack.triggersActionsUI.sections.alertDetails.viewAlertInAppButtonLabel"
+                      defaultMessage="View in app"
+                    />
+                  </EuiButtonEmpty>
+                </EuiFlexItem>
+                <EuiFlexItem grow={false}>
+                  <EuiButtonEmpty disabled={true} iconType="menuLeft">
+                    <FormattedMessage
+                      id="xpack.triggersActionsUI.sections.alertDetails.activityLogButtonLabel"
+                      defaultMessage="Activity Log"
+                    />
+                  </EuiButtonEmpty>
+                </EuiFlexItem>
+              </EuiFlexGroup>
+            </EuiPageContentHeaderSection>
+          </EuiPageContentHeader>
+          <EuiPageContentBody>
+            <EuiFlexGroup wrap responsive={false} gutterSize="m">
+              <EuiFlexItem grow={false}>
+                <EuiFlexGroup wrap responsive={false} gutterSize="xs">
+                  <EuiFlexItem grow={false}>
+                    <EuiBadge data-test-subj="alertTypeLabel">{alertType.name}</EuiBadge>
+                  </EuiFlexItem>
+                  {firstAction && (
+                    <EuiFlexItem grow={false}>
+                      <EuiBadge color="hollow" data-test-subj="actionTypeLabel">
+                        {actionTypesByTypeId[firstAction.actionTypeId].name ??
+                          firstAction.actionTypeId}
+                      </EuiBadge>
+                    </EuiFlexItem>
+                  )}
+                  {otherActions.length ? (
+                    <EuiFlexItem grow={false} data-test-subj="actionCountLabel">
+                      <EuiBadge color="hollow">+{otherActions.length}</EuiBadge>
+                    </EuiFlexItem>
+                  ) : null}
+                </EuiFlexGroup>
+              </EuiFlexItem>
+              <EuiFlexItem grow={true}>
+                <EuiFlexGroup wrap responsive={false} gutterSize="m">
+                  <EuiFlexItem grow={false}>
+                    <EuiSwitch
+                      name="enable"
+                      disabled={!canSave}
+                      checked={isEnabled}
+                      data-test-subj="enableSwitch"
+                      onChange={async () => {
+                        if (isEnabled) {
+                          setIsEnabled(false);
+                          await disableAlert(alert);
+                        } else {
+                          setIsEnabled(true);
+                          await enableAlert(alert);
+                        }
+                      }}
+                      label={
+                        <FormattedMessage
+                          id="xpack.triggersActionsUI.sections.alertsList.collapsedItemActons.enableTitle"
+                          defaultMessage="Enable"
+                        />
+                      }
+                    />
+                  </EuiFlexItem>
+                  <EuiFlexItem grow={false}>
+                    <EuiSwitch
+                      name="mute"
+                      checked={isMuted}
+                      disabled={!canSave || !isEnabled}
+                      data-test-subj="muteSwitch"
+                      onChange={async () => {
+                        if (isMuted) {
+                          setIsMuted(false);
+                          await unmuteAlert(alert);
+                        } else {
+                          setIsMuted(true);
+                          await muteAlert(alert);
+                        }
+                      }}
+                      label={
+                        <FormattedMessage
+                          id="xpack.triggersActionsUI.sections.alertsList.collapsedItemActons.muteTitle"
+                          defaultMessage="Mute"
+                        />
+                      }
+                    />
+                  </EuiFlexItem>
+                </EuiFlexGroup>
+              </EuiFlexItem>
+            </EuiFlexGroup>
+          </EuiPageContentBody>
+        </EuiPageContent>
+      </EuiPageBody>
+    </EuiPage>
+  );
+};
+
+export const AlertDetailsWithApi = withBulkAlertOperations(AlertDetails);
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.test.tsx
new file mode 100644
index 0000000000000..7a40104e97d9f
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.test.tsx
@@ -0,0 +1,409 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import * as React from 'react';
+import uuid from 'uuid';
+import { shallow } from 'enzyme';
+import { createMemoryHistory, createLocation } from 'history';
+import { ToastsApi } from 'kibana/public';
+import { AlertDetailsRoute, getAlertData } from './alert_details_route';
+import { Alert } from '../../../../types';
+import { EuiLoadingSpinner } from '@elastic/eui';
+
+jest.mock('../../../app_context', () => {
+  const toastNotifications = jest.fn();
+  return {
+    useAppDependencies: jest.fn(() => ({ toastNotifications })),
+  };
+});
+describe('alert_details_route', () => {
+  it('render a loader while fetching data', () => {
+    const alert = mockAlert();
+
+    expect(
+      shallow(
+        <AlertDetailsRoute {...mockRouterProps(alert)} {...mockApis()} />
+      ).containsMatchingElement(<EuiLoadingSpinner size="l" />)
+    ).toBeTruthy();
+  });
+});
+
+describe('getAlertData useEffect handler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('fetches alert', async () => {
+    const alert = mockAlert();
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementationOnce(async () => alert);
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+
+    expect(loadAlert).toHaveBeenCalledWith(alert.id);
+    expect(setAlert).toHaveBeenCalledWith(alert);
+  });
+
+  it('fetches alert and action types', async () => {
+    const actionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: actionType.id,
+          params: {},
+        },
+      ],
+    });
+    const alertType = {
+      id: alert.alertTypeId,
+      name: 'type name',
+    };
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => alert);
+    loadAlertTypes.mockImplementation(async () => [alertType]);
+    loadActionTypes.mockImplementation(async () => [actionType]);
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+
+    expect(loadAlertTypes).toHaveBeenCalledTimes(1);
+    expect(loadActionTypes).toHaveBeenCalledTimes(1);
+
+    expect(setAlertType).toHaveBeenCalledWith(alertType);
+    expect(setActionTypes).toHaveBeenCalledWith([actionType]);
+  });
+
+  it('displays an error if the alert isnt found', async () => {
+    const actionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: actionType.id,
+          params: {},
+        },
+      ],
+    });
+
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => {
+      throw new Error('OMG');
+    });
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+    expect(toastNotifications.addDanger).toHaveBeenCalledTimes(1);
+    expect(toastNotifications.addDanger).toHaveBeenCalledWith({
+      title: 'Unable to load alert: OMG',
+    });
+  });
+
+  it('displays an error if the alert type isnt loaded', async () => {
+    const actionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: actionType.id,
+          params: {},
+        },
+      ],
+    });
+
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => alert);
+
+    loadAlertTypes.mockImplementation(async () => {
+      throw new Error('OMG no alert type');
+    });
+    loadActionTypes.mockImplementation(async () => [actionType]);
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+    expect(toastNotifications.addDanger).toHaveBeenCalledTimes(1);
+    expect(toastNotifications.addDanger).toHaveBeenCalledWith({
+      title: 'Unable to load alert: OMG no alert type',
+    });
+  });
+
+  it('displays an error if the action type isnt loaded', async () => {
+    const actionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: actionType.id,
+          params: {},
+        },
+      ],
+    });
+    const alertType = {
+      id: alert.alertTypeId,
+      name: 'type name',
+    };
+
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => alert);
+
+    loadAlertTypes.mockImplementation(async () => [alertType]);
+    loadActionTypes.mockImplementation(async () => {
+      throw new Error('OMG no action type');
+    });
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+    expect(toastNotifications.addDanger).toHaveBeenCalledTimes(1);
+    expect(toastNotifications.addDanger).toHaveBeenCalledWith({
+      title: 'Unable to load alert: OMG no action type',
+    });
+  });
+
+  it('displays an error if the alert type isnt found', async () => {
+    const actionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: actionType.id,
+          params: {},
+        },
+      ],
+    });
+
+    const alertType = {
+      id: uuid.v4(),
+      name: 'type name',
+    };
+
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => alert);
+    loadAlertTypes.mockImplementation(async () => [alertType]);
+    loadActionTypes.mockImplementation(async () => [actionType]);
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+    expect(toastNotifications.addDanger).toHaveBeenCalledTimes(1);
+    expect(toastNotifications.addDanger).toHaveBeenCalledWith({
+      title: `Unable to load alert: Invalid Alert Type: ${alert.alertTypeId}`,
+    });
+  });
+
+  it('displays an error if an action type isnt found', async () => {
+    const availableActionType = {
+      id: '.server-log',
+      name: 'Server log',
+      enabled: true,
+    };
+    const missingActionType = {
+      id: '.noop',
+      name: 'No Op',
+      enabled: true,
+    };
+    const alert = mockAlert({
+      actions: [
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: availableActionType.id,
+          params: {},
+        },
+        {
+          group: '',
+          id: uuid.v4(),
+          actionTypeId: missingActionType.id,
+          params: {},
+        },
+      ],
+    });
+
+    const alertType = {
+      id: uuid.v4(),
+      name: 'type name',
+    };
+
+    const { loadAlert, loadAlertTypes, loadActionTypes } = mockApis();
+    const { setAlert, setAlertType, setActionTypes } = mockStateSetter();
+
+    loadAlert.mockImplementation(async () => alert);
+    loadAlertTypes.mockImplementation(async () => [alertType]);
+    loadActionTypes.mockImplementation(async () => [availableActionType]);
+
+    const toastNotifications = ({
+      addDanger: jest.fn(),
+    } as unknown) as ToastsApi;
+    await getAlertData(
+      alert.id,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+    expect(toastNotifications.addDanger).toHaveBeenCalledTimes(1);
+    expect(toastNotifications.addDanger).toHaveBeenCalledWith({
+      title: `Unable to load alert: Invalid Action Type: ${missingActionType.id}`,
+    });
+  });
+});
+
+function mockApis() {
+  return {
+    loadAlert: jest.fn(),
+    loadAlertTypes: jest.fn(),
+    loadActionTypes: jest.fn(),
+  };
+}
+
+function mockStateSetter() {
+  return {
+    setAlert: jest.fn(),
+    setAlertType: jest.fn(),
+    setActionTypes: jest.fn(),
+  };
+}
+
+function mockRouterProps(alert: Alert) {
+  return {
+    match: {
+      isExact: false,
+      path: `/alert/${alert.id}`,
+      url: '',
+      params: { alertId: alert.id },
+    },
+    history: createMemoryHistory(),
+    location: createLocation(`/alert/${alert.id}`),
+  };
+}
+function mockAlert(overloads: Partial<Alert> = {}): Alert {
+  return {
+    id: uuid.v4(),
+    enabled: true,
+    name: `alert-${uuid.v4()}`,
+    tags: [],
+    alertTypeId: '.noop',
+    consumer: 'consumer',
+    schedule: { interval: '1m' },
+    actions: [],
+    params: {},
+    createdBy: null,
+    updatedBy: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    apiKeyOwner: null,
+    throttle: null,
+    muteAll: false,
+    mutedInstanceIds: [],
+    ...overloads,
+  };
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.tsx
new file mode 100644
index 0000000000000..4e00ea304d987
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alert_details/components/alert_details_route.tsx
@@ -0,0 +1,118 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { i18n } from '@kbn/i18n';
+import React, { useState, useEffect } from 'react';
+import { RouteComponentProps } from 'react-router-dom';
+import { EuiLoadingSpinner } from '@elastic/eui';
+import { ToastsApi } from 'kibana/public';
+import { Alert, AlertType, ActionType } from '../../../../types';
+import { useAppDependencies } from '../../../app_context';
+import { AlertDetailsWithApi as AlertDetails } from './alert_details';
+import { throwIfAbsent, throwIfIsntContained } from '../../../lib/value_validators';
+import {
+  ComponentOpts as AlertApis,
+  withBulkAlertOperations,
+} from '../../common/components/with_bulk_alert_api_operations';
+import {
+  ComponentOpts as ActionApis,
+  withActionOperations,
+} from '../../common/components/with_actions_api_operations';
+
+type AlertDetailsRouteProps = RouteComponentProps<{
+  alertId: string;
+}> &
+  Pick<ActionApis, 'loadActionTypes'> &
+  Pick<AlertApis, 'loadAlert' | 'loadAlertTypes'>;
+
+export const AlertDetailsRoute: React.FunctionComponent<AlertDetailsRouteProps> = ({
+  match: {
+    params: { alertId },
+  },
+  loadAlert,
+  loadAlertTypes,
+  loadActionTypes,
+}) => {
+  const { http, toastNotifications } = useAppDependencies();
+
+  const [alert, setAlert] = useState<Alert | null>(null);
+  const [alertType, setAlertType] = useState<AlertType | null>(null);
+  const [actionTypes, setActionTypes] = useState<ActionType[] | null>(null);
+
+  useEffect(() => {
+    getAlertData(
+      alertId,
+      loadAlert,
+      loadAlertTypes,
+      loadActionTypes,
+      setAlert,
+      setAlertType,
+      setActionTypes,
+      toastNotifications
+    );
+  }, [alertId, http, loadActionTypes, loadAlert, loadAlertTypes, toastNotifications]);
+
+  return alert && alertType && actionTypes ? (
+    <AlertDetails alert={alert} alertType={alertType} actionTypes={actionTypes} />
+  ) : (
+    <div
+      style={{
+        textAlign: 'center',
+        margin: '4em 0em',
+      }}
+    >
+      <EuiLoadingSpinner size="l" />
+    </div>
+  );
+};
+
+export async function getAlertData(
+  alertId: string,
+  loadAlert: AlertApis['loadAlert'],
+  loadAlertTypes: AlertApis['loadAlertTypes'],
+  loadActionTypes: ActionApis['loadActionTypes'],
+  setAlert: React.Dispatch<React.SetStateAction<Alert | null>>,
+  setAlertType: React.Dispatch<React.SetStateAction<AlertType | null>>,
+  setActionTypes: React.Dispatch<React.SetStateAction<ActionType[] | null>>,
+  toastNotifications: Pick<ToastsApi, 'addDanger'>
+) {
+  try {
+    const loadedAlert = await loadAlert(alertId);
+    setAlert(loadedAlert);
+
+    const [loadedAlertType, loadedActionTypes] = await Promise.all<AlertType, ActionType[]>([
+      loadAlertTypes()
+        .then(types => types.find(type => type.id === loadedAlert.alertTypeId))
+        .then(throwIfAbsent(`Invalid Alert Type: ${loadedAlert.alertTypeId}`)),
+      loadActionTypes().then(
+        throwIfIsntContained(
+          new Set(loadedAlert.actions.map(action => action.actionTypeId)),
+          (requiredActionType: string) => `Invalid Action Type: ${requiredActionType}`,
+          (action: ActionType) => action.id
+        )
+      ),
+    ]);
+
+    setAlertType(loadedAlertType);
+    setActionTypes(loadedActionTypes);
+  } catch (e) {
+    toastNotifications.addDanger({
+      title: i18n.translate(
+        'xpack.triggersActionsUI.sections.alertDetails.unableToLoadAlertMessage',
+        {
+          defaultMessage: 'Unable to load alert: {message}',
+          values: {
+            message: e.message,
+          },
+        }
+      ),
+    });
+  }
+}
+
+export const AlertDetailsRouteWithApi = withActionOperations(
+  withBulkAlertOperations(AlertDetailsRoute)
+);
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.test.tsx
index ff1510ea873d3..f410fff44172f 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.test.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.test.tsx
@@ -21,7 +21,14 @@ jest.mock('../../../lib/alert_api', () => ({
   loadAlerts: jest.fn(),
   loadAlertTypes: jest.fn(),
 }));
-
+jest.mock('react-router-dom', () => ({
+  useHistory: () => ({
+    push: jest.fn(),
+  }),
+  useLocation: () => ({
+    pathname: '/triggersActions/alerts/',
+  }),
+}));
 const actionTypeRegistry = actionTypeRegistryMock.create();
 const alertTypeRegistry = alertTypeRegistryMock.create();
 
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.tsx
index 12122983161bd..32de924f63e80 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/alerts_list.tsx
@@ -15,19 +15,23 @@ import {
   EuiFlexItem,
   EuiIcon,
   EuiSpacer,
+  EuiLink,
 } from '@elastic/eui';
+import { useHistory } from 'react-router-dom';
 
 import { AlertsContextProvider } from '../../../context/alerts_context';
 import { useAppDependencies } from '../../../app_context';
 import { ActionType, Alert, AlertTableItem, AlertTypeIndex, Pagination } from '../../../../types';
 import { AlertAdd } from '../../alert_add';
-import { BulkActionPopover } from './bulk_action_popover';
-import { CollapsedItemActions } from './collapsed_item_actions';
+import { BulkOperationPopover } from '../../common/components/bulk_operation_popover';
+import { AlertQuickEditButtonsWithApi as AlertQuickEditButtons } from '../../common/components/alert_quick_edit_buttons';
+import { CollapsedItemActionsWithApi as CollapsedItemActions } from './collapsed_item_actions';
 import { TypeFilter } from './type_filter';
 import { ActionTypeFilter } from './action_type_filter';
 import { loadAlerts, loadAlertTypes } from '../../../lib/alert_api';
 import { loadActionTypes } from '../../../lib/action_connector_api';
 import { hasDeleteAlertsCapability, hasSaveAlertsCapability } from '../../../lib/capabilities';
+import { routeToAlertDetails } from '../../../constants';
 
 const ENTER_KEY = 13;
 
@@ -43,6 +47,7 @@ interface AlertState {
 }
 
 export const AlertsList: React.FunctionComponent = () => {
+  const history = useHistory();
   const { http, injectedMetadata, toastNotifications, capabilities } = useAppDependencies();
   const canDelete = hasDeleteAlertsCapability(capabilities);
   const canSave = hasSaveAlertsCapability(capabilities);
@@ -151,6 +156,18 @@ export const AlertsList: React.FunctionComponent = () => {
       sortable: false,
       truncateText: true,
       'data-test-subj': 'alertsTableCell-name',
+      render: (name: string, alert: AlertTableItem) => {
+        return (
+          <EuiLink
+            title={name}
+            onClick={() => {
+              history.push(routeToAlertDetails.replace(`:alertId`, alert.id));
+            }}
+          >
+            {name}
+          </EuiLink>
+        );
+      },
     },
     {
       field: 'tagsText',
@@ -236,17 +253,19 @@ export const AlertsList: React.FunctionComponent = () => {
           <EuiFlexGroup>
             {selectedIds.length > 0 && canDelete && (
               <EuiFlexItem grow={false}>
-                <BulkActionPopover
-                  selectedItems={convertAlertsToTableItems(
-                    filterAlertsById(alertsState.data, selectedIds),
-                    alertTypesState.data
-                  )}
-                  onPerformingAction={() => setIsPerformingAction(true)}
-                  onActionPerformed={() => {
-                    loadAlertsData();
-                    setIsPerformingAction(false);
-                  }}
-                />
+                <BulkOperationPopover>
+                  <AlertQuickEditButtons
+                    selectedItems={convertAlertsToTableItems(
+                      filterAlertsById(alertsState.data, selectedIds),
+                      alertTypesState.data
+                    )}
+                    onPerformingAction={() => setIsPerformingAction(true)}
+                    onActionPerformed={() => {
+                      loadAlertsData();
+                      setIsPerformingAction(false);
+                    }}
+                  />
+                </BulkOperationPopover>
               </EuiFlexItem>
             )}
             <EuiFlexItem>
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/collapsed_item_actions.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/collapsed_item_actions.tsx
index aa1c6dd7c5b9a..2bac159ed79ed 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/collapsed_item_actions.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/collapsed_item_actions.tsx
@@ -20,23 +20,25 @@ import { AlertTableItem } from '../../../../types';
 import { useAppDependencies } from '../../../app_context';
 import { hasDeleteAlertsCapability, hasSaveAlertsCapability } from '../../../lib/capabilities';
 import {
-  deleteAlerts,
-  disableAlerts,
-  enableAlerts,
-  muteAlerts,
-  unmuteAlerts,
-} from '../../../lib/alert_api';
+  ComponentOpts as BulkOperationsComponentOpts,
+  withBulkAlertOperations,
+} from '../../common/components/with_bulk_alert_api_operations';
 
-export interface ComponentOpts {
+export type ComponentOpts = {
   item: AlertTableItem;
   onAlertChanged: () => void;
-}
+} & BulkOperationsComponentOpts;
 
 export const CollapsedItemActions: React.FunctionComponent<ComponentOpts> = ({
   item,
   onAlertChanged,
+  disableAlert,
+  enableAlert,
+  unmuteAlert,
+  muteAlert,
+  deleteAlert,
 }: ComponentOpts) => {
-  const { http, capabilities } = useAppDependencies();
+  const { capabilities } = useAppDependencies();
 
   const canDelete = hasDeleteAlertsCapability(capabilities);
   const canSave = hasSaveAlertsCapability(capabilities);
@@ -71,9 +73,9 @@ export const CollapsedItemActions: React.FunctionComponent<ComponentOpts> = ({
           data-test-subj="enableSwitch"
           onChange={async () => {
             if (item.enabled) {
-              await disableAlerts({ http, ids: [item.id] });
+              await disableAlert(item);
             } else {
-              await enableAlerts({ http, ids: [item.id] });
+              await enableAlert(item);
             }
             onAlertChanged();
           }}
@@ -93,9 +95,9 @@ export const CollapsedItemActions: React.FunctionComponent<ComponentOpts> = ({
           data-test-subj="muteSwitch"
           onChange={async () => {
             if (item.muteAll) {
-              await unmuteAlerts({ http, ids: [item.id] });
+              await unmuteAlert(item);
             } else {
-              await muteAlerts({ http, ids: [item.id] });
+              await muteAlert(item);
             }
             onAlertChanged();
           }}
@@ -115,7 +117,7 @@ export const CollapsedItemActions: React.FunctionComponent<ComponentOpts> = ({
             color="text"
             data-test-subj="deleteAlert"
             onClick={async () => {
-              await deleteAlerts({ http, ids: [item.id] });
+              await deleteAlert(item);
               onAlertChanged();
             }}
           >
@@ -129,3 +131,5 @@ export const CollapsedItemActions: React.FunctionComponent<ComponentOpts> = ({
     </EuiPopover>
   );
 };
+
+export const CollapsedItemActionsWithApi = withBulkAlertOperations(CollapsedItemActions);
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/bulk_action_popover.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/alert_quick_edit_buttons.tsx
similarity index 52%
rename from x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/bulk_action_popover.tsx
rename to x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/alert_quick_edit_buttons.tsx
index 59ec52ac83a6c..9635e6cd11983 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/alerts_list/components/bulk_action_popover.tsx
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/alert_quick_edit_buttons.tsx
@@ -5,34 +5,35 @@
  */
 
 import { i18n } from '@kbn/i18n';
-import React, { useState } from 'react';
+import React, { useState, Fragment } from 'react';
 import { FormattedMessage } from '@kbn/i18n/react';
-import { EuiButton, EuiButtonEmpty, EuiFormRow, EuiPopover } from '@elastic/eui';
+import { EuiButtonEmpty } from '@elastic/eui';
 
-import { AlertTableItem } from '../../../../types';
+import { Alert } from '../../../../types';
 import { useAppDependencies } from '../../../app_context';
 import {
-  deleteAlerts,
-  disableAlerts,
-  enableAlerts,
-  muteAlerts,
-  unmuteAlerts,
-} from '../../../lib/alert_api';
+  withBulkAlertOperations,
+  ComponentOpts as BulkOperationsComponentOpts,
+} from './with_bulk_alert_api_operations';
 
-export interface ComponentOpts {
-  selectedItems: AlertTableItem[];
-  onPerformingAction: () => void;
-  onActionPerformed: () => void;
-}
+export type ComponentOpts = {
+  selectedItems: Alert[];
+  onPerformingAction?: () => void;
+  onActionPerformed?: () => void;
+} & BulkOperationsComponentOpts;
 
-export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
+export const AlertQuickEditButtons: React.FunctionComponent<ComponentOpts> = ({
   selectedItems,
-  onPerformingAction,
-  onActionPerformed,
+  onPerformingAction = noop,
+  onActionPerformed = noop,
+  muteAlerts,
+  unmuteAlerts,
+  enableAlerts,
+  disableAlerts,
+  deleteAlerts,
 }: ComponentOpts) => {
-  const { http, toastNotifications } = useAppDependencies();
+  const { toastNotifications } = useAppDependencies();
 
-  const [isPopoverOpen, setIsPopoverOpen] = useState<boolean>(false);
   const [isMutingAlerts, setIsMutingAlerts] = useState<boolean>(false);
   const [isUnmutingAlerts, setIsUnmutingAlerts] = useState<boolean>(false);
   const [isEnablingAlerts, setIsEnablingAlerts] = useState<boolean>(false);
@@ -47,9 +48,8 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   async function onmMuteAllClick() {
     onPerformingAction();
     setIsMutingAlerts(true);
-    const ids = selectedItems.filter(item => !isAlertMuted(item)).map(item => item.id);
     try {
-      await muteAlerts({ http, ids });
+      await muteAlerts(selectedItems);
     } catch (e) {
       toastNotifications.addDanger({
         title: i18n.translate(
@@ -68,9 +68,8 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   async function onUnmuteAllClick() {
     onPerformingAction();
     setIsUnmutingAlerts(true);
-    const ids = selectedItems.filter(isAlertMuted).map(item => item.id);
     try {
-      await unmuteAlerts({ http, ids });
+      await unmuteAlerts(selectedItems);
     } catch (e) {
       toastNotifications.addDanger({
         title: i18n.translate(
@@ -89,9 +88,8 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   async function onEnableAllClick() {
     onPerformingAction();
     setIsEnablingAlerts(true);
-    const ids = selectedItems.filter(isAlertDisabled).map(item => item.id);
     try {
-      await enableAlerts({ http, ids });
+      await enableAlerts(selectedItems);
     } catch (e) {
       toastNotifications.addDanger({
         title: i18n.translate(
@@ -110,9 +108,8 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   async function onDisableAllClick() {
     onPerformingAction();
     setIsDisablingAlerts(true);
-    const ids = selectedItems.filter(item => !isAlertDisabled(item)).map(item => item.id);
     try {
-      await disableAlerts({ http, ids });
+      await disableAlerts(selectedItems);
     } catch (e) {
       toastNotifications.addDanger({
         title: i18n.translate(
@@ -131,9 +128,8 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   async function deleteSelectedItems() {
     onPerformingAction();
     setIsDeletingAlerts(true);
-    const ids = selectedItems.map(item => item.id);
     try {
-      await deleteAlerts({ http, ids });
+      await deleteAlerts(selectedItems);
     } catch (e) {
       toastNotifications.addDanger({
         title: i18n.translate(
@@ -150,104 +146,83 @@ export const BulkActionPopover: React.FunctionComponent<ComponentOpts> = ({
   }
 
   return (
-    <EuiPopover
-      isOpen={isPopoverOpen}
-      closePopover={() => setIsPopoverOpen(false)}
-      data-test-subj="bulkAction"
-      button={
-        <EuiButton
-          iconType="arrowDown"
-          iconSide="right"
-          onClick={() => setIsPopoverOpen(!isPopoverOpen)}
+    <Fragment>
+      {!allAlertsMuted && (
+        <EuiButtonEmpty
+          onClick={onmMuteAllClick}
+          isLoading={isMutingAlerts}
+          isDisabled={isPerformingAction}
+          data-test-subj="muteAll"
         >
           <FormattedMessage
-            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.buttonTitle"
-            defaultMessage="Manage alerts"
+            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.muteAllTitle"
+            defaultMessage="Mute"
           />
-        </EuiButton>
-      }
-    >
-      {!allAlertsMuted && (
-        <EuiFormRow>
-          <EuiButtonEmpty
-            onClick={onmMuteAllClick}
-            isLoading={isMutingAlerts}
-            isDisabled={isPerformingAction}
-            data-test-subj="muteAll"
-          >
-            <FormattedMessage
-              id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.muteAllTitle"
-              defaultMessage="Mute"
-            />
-          </EuiButtonEmpty>
-        </EuiFormRow>
+        </EuiButtonEmpty>
       )}
       {allAlertsMuted && (
-        <EuiFormRow>
-          <EuiButtonEmpty
-            onClick={onUnmuteAllClick}
-            isLoading={isUnmutingAlerts}
-            isDisabled={isPerformingAction}
-            data-test-subj="unmuteAll"
-          >
-            <FormattedMessage
-              id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.unmuteAllTitle"
-              defaultMessage="Unmute"
-            />
-          </EuiButtonEmpty>
-        </EuiFormRow>
+        <EuiButtonEmpty
+          onClick={onUnmuteAllClick}
+          isLoading={isUnmutingAlerts}
+          isDisabled={isPerformingAction}
+          data-test-subj="unmuteAll"
+        >
+          <FormattedMessage
+            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.unmuteAllTitle"
+            defaultMessage="Unmute"
+          />
+        </EuiButtonEmpty>
       )}
       {allAlertsDisabled && (
-        <EuiFormRow>
-          <EuiButtonEmpty
-            onClick={onEnableAllClick}
-            isLoading={isEnablingAlerts}
-            isDisabled={isPerformingAction}
-            data-test-subj="enableAll"
-          >
-            <FormattedMessage
-              id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.enableAllTitle"
-              defaultMessage="Enable"
-            />
-          </EuiButtonEmpty>
-        </EuiFormRow>
+        <EuiButtonEmpty
+          onClick={onEnableAllClick}
+          isLoading={isEnablingAlerts}
+          isDisabled={isPerformingAction}
+          data-test-subj="enableAll"
+        >
+          <FormattedMessage
+            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.enableAllTitle"
+            defaultMessage="Enable"
+          />
+        </EuiButtonEmpty>
       )}
       {!allAlertsDisabled && (
-        <EuiFormRow>
-          <EuiButtonEmpty
-            onClick={onDisableAllClick}
-            isLoading={isDisablingAlerts}
-            isDisabled={isPerformingAction}
-            data-test-subj="disableAll"
-          >
-            <FormattedMessage
-              id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.disableAllTitle"
-              defaultMessage="Disable"
-            />
-          </EuiButtonEmpty>
-        </EuiFormRow>
-      )}
-      <EuiFormRow>
         <EuiButtonEmpty
-          onClick={deleteSelectedItems}
-          isLoading={isDeletingAlerts}
+          onClick={onDisableAllClick}
+          isLoading={isDisablingAlerts}
           isDisabled={isPerformingAction}
-          data-test-subj="deleteAll"
+          data-test-subj="disableAll"
         >
           <FormattedMessage
-            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.deleteAllTitle"
-            defaultMessage="Delete"
+            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.disableAllTitle"
+            defaultMessage="Disable"
           />
         </EuiButtonEmpty>
-      </EuiFormRow>
-    </EuiPopover>
+      )}
+
+      <EuiButtonEmpty
+        onClick={deleteSelectedItems}
+        isLoading={isDeletingAlerts}
+        isDisabled={isPerformingAction}
+        data-test-subj="deleteAll"
+      >
+        <FormattedMessage
+          id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.deleteAllTitle"
+          defaultMessage="Delete"
+        />
+      </EuiButtonEmpty>
+    </Fragment>
   );
 };
 
-function isAlertDisabled(alert: AlertTableItem) {
+export const AlertQuickEditButtonsWithApi = withBulkAlertOperations(AlertQuickEditButtons);
+
+function isAlertDisabled(alert: Alert) {
   return alert.enabled === false;
 }
 
-function isAlertMuted(alert: AlertTableItem) {
+function isAlertMuted(alert: Alert) {
   return alert.muteAll === true;
 }
+
+function noop() {}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/bulk_operation_popover.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/bulk_operation_popover.tsx
new file mode 100644
index 0000000000000..d0fd0e1792818
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/bulk_operation_popover.tsx
@@ -0,0 +1,42 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import React, { useState } from 'react';
+import { FormattedMessage } from '@kbn/i18n/react';
+import { EuiButton, EuiFormRow, EuiPopover } from '@elastic/eui';
+
+export const BulkOperationPopover: React.FunctionComponent = ({ children }) => {
+  const [isPopoverOpen, setIsPopoverOpen] = useState<boolean>(false);
+
+  return (
+    <EuiPopover
+      isOpen={isPopoverOpen}
+      closePopover={() => setIsPopoverOpen(false)}
+      data-test-subj="bulkAction"
+      button={
+        <EuiButton
+          iconType="arrowDown"
+          iconSide="right"
+          onClick={() => setIsPopoverOpen(!isPopoverOpen)}
+        >
+          <FormattedMessage
+            id="xpack.triggersActionsUI.sections.alertsList.bulkActionPopover.buttonTitle"
+            defaultMessage="Manage alerts"
+          />
+        </EuiButton>
+      }
+    >
+      {children &&
+        React.Children.map(children, child =>
+          React.isValidElement(child) ? (
+            <EuiFormRow>{React.cloneElement(child, {})}</EuiFormRow>
+          ) : (
+            child
+          )
+        )}
+    </EuiPopover>
+  );
+};
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.test.tsx
new file mode 100644
index 0000000000000..dd6b8775ba3d0
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.test.tsx
@@ -0,0 +1,51 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import * as React from 'react';
+import { shallow, mount } from 'enzyme';
+import { withActionOperations, ComponentOpts } from './with_actions_api_operations';
+import * as actionApis from '../../../lib/action_connector_api';
+import { useAppDependencies } from '../../../app_context';
+
+jest.mock('../../../lib/action_connector_api');
+
+jest.mock('../../../app_context', () => {
+  const http = jest.fn();
+  return {
+    useAppDependencies: jest.fn(() => ({
+      http,
+    })),
+  };
+});
+
+describe('with_action_api_operations', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('extends any component with Action Api methods', () => {
+    const ComponentToExtend = (props: ComponentOpts) => {
+      expect(typeof props.loadActionTypes).toEqual('function');
+      return <div />;
+    };
+
+    const ExtendedComponent = withActionOperations(ComponentToExtend);
+    expect(shallow(<ExtendedComponent />).type()).toEqual(ComponentToExtend);
+  });
+
+  it('loadActionTypes calls the loadActionTypes api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ loadActionTypes }: ComponentOpts) => {
+      return <button onClick={() => loadActionTypes()}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withActionOperations(ComponentToExtend);
+    const component = mount(<ExtendedComponent />);
+    component.find('button').simulate('click');
+
+    expect(actionApis.loadActionTypes).toHaveBeenCalledTimes(1);
+    expect(actionApis.loadActionTypes).toHaveBeenCalledWith({ http });
+  });
+});
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.tsx
new file mode 100644
index 0000000000000..45e6c6b10532c
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_actions_api_operations.tsx
@@ -0,0 +1,28 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import React from 'react';
+
+import { ActionType } from '../../../../types';
+import { useAppDependencies } from '../../../app_context';
+import { loadActionTypes } from '../../../lib/action_connector_api';
+
+export interface ComponentOpts {
+  loadActionTypes: () => Promise<ActionType[]>;
+}
+
+export type PropsWithOptionalApiHandlers<T> = Omit<T, keyof ComponentOpts> & Partial<ComponentOpts>;
+
+export function withActionOperations<T>(
+  WrappedComponent: React.ComponentType<T & ComponentOpts>
+): React.FunctionComponent<PropsWithOptionalApiHandlers<T>> {
+  return (props: PropsWithOptionalApiHandlers<T>) => {
+    const { http } = useAppDependencies();
+    return (
+      <WrappedComponent {...(props as T)} loadActionTypes={async () => loadActionTypes({ http })} />
+    );
+  };
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.test.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.test.tsx
new file mode 100644
index 0000000000000..30a065479ce33
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.test.tsx
@@ -0,0 +1,269 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import * as React from 'react';
+import { shallow, mount } from 'enzyme';
+import uuid from 'uuid';
+import { withBulkAlertOperations, ComponentOpts } from './with_bulk_alert_api_operations';
+import * as alertApi from '../../../lib/alert_api';
+import { useAppDependencies } from '../../../app_context';
+import { Alert } from '../../../../types';
+
+jest.mock('../../../lib/alert_api');
+
+jest.mock('../../../app_context', () => {
+  const http = jest.fn();
+  return {
+    useAppDependencies: jest.fn(() => ({
+      http,
+      legacy: {
+        capabilities: {
+          get: jest.fn(() => ({})),
+        },
+      },
+    })),
+  };
+});
+
+describe('with_bulk_alert_api_operations', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('extends any component with AlertApi methods', () => {
+    const ComponentToExtend = (props: ComponentOpts) => {
+      expect(typeof props.muteAlerts).toEqual('function');
+      expect(typeof props.unmuteAlerts).toEqual('function');
+      expect(typeof props.enableAlerts).toEqual('function');
+      expect(typeof props.disableAlerts).toEqual('function');
+      expect(typeof props.deleteAlerts).toEqual('function');
+      expect(typeof props.muteAlert).toEqual('function');
+      expect(typeof props.unmuteAlert).toEqual('function');
+      expect(typeof props.enableAlert).toEqual('function');
+      expect(typeof props.disableAlert).toEqual('function');
+      expect(typeof props.deleteAlert).toEqual('function');
+      expect(typeof props.loadAlert).toEqual('function');
+      expect(typeof props.loadAlertTypes).toEqual('function');
+      return <div />;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    expect(shallow(<ExtendedComponent />).type()).toEqual(ComponentToExtend);
+  });
+
+  // single alert
+  it('muteAlert calls the muteAlert api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ muteAlert, alert }: ComponentOpts & { alert: Alert }) => {
+      return <button onClick={() => muteAlert(alert)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alert = mockAlert();
+    const component = mount(<ExtendedComponent alert={alert} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.muteAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.muteAlert).toHaveBeenCalledWith({ id: alert.id, http });
+  });
+
+  it('unmuteAlert calls the unmuteAlert api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ unmuteAlert, alert }: ComponentOpts & { alert: Alert }) => {
+      return <button onClick={() => unmuteAlert(alert)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alert = mockAlert({ muteAll: true });
+    const component = mount(<ExtendedComponent alert={alert} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.unmuteAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.unmuteAlert).toHaveBeenCalledWith({ id: alert.id, http });
+  });
+
+  it('enableAlert calls the muteAlerts api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ enableAlert, alert }: ComponentOpts & { alert: Alert }) => {
+      return <button onClick={() => enableAlert(alert)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alert = mockAlert({ enabled: false });
+    const component = mount(<ExtendedComponent alert={alert} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.enableAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.enableAlert).toHaveBeenCalledWith({ id: alert.id, http });
+  });
+
+  it('disableAlert calls the disableAlert api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ disableAlert, alert }: ComponentOpts & { alert: Alert }) => {
+      return <button onClick={() => disableAlert(alert)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alert = mockAlert();
+    const component = mount(<ExtendedComponent alert={alert} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.disableAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.disableAlert).toHaveBeenCalledWith({ id: alert.id, http });
+  });
+
+  it('deleteAlert calls the deleteAlert api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ deleteAlert, alert }: ComponentOpts & { alert: Alert }) => {
+      return <button onClick={() => deleteAlert(alert)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alert = mockAlert();
+    const component = mount(<ExtendedComponent alert={alert} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.deleteAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.deleteAlert).toHaveBeenCalledWith({ id: alert.id, http });
+  });
+
+  // bulk alerts
+  it('muteAlerts calls the muteAlerts api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ muteAlerts, alerts }: ComponentOpts & { alerts: Alert[] }) => {
+      return <button onClick={() => muteAlerts(alerts)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alerts = [mockAlert(), mockAlert()];
+    const component = mount(<ExtendedComponent alerts={alerts} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.muteAlerts).toHaveBeenCalledTimes(1);
+    expect(alertApi.muteAlerts).toHaveBeenCalledWith({ ids: [alerts[0].id, alerts[1].id], http });
+  });
+
+  it('unmuteAlerts calls the unmuteAlerts api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ unmuteAlerts, alerts }: ComponentOpts & { alerts: Alert[] }) => {
+      return <button onClick={() => unmuteAlerts(alerts)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alerts = [mockAlert({ muteAll: true }), mockAlert({ muteAll: true })];
+    const component = mount(<ExtendedComponent alerts={alerts} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.unmuteAlerts).toHaveBeenCalledTimes(1);
+    expect(alertApi.unmuteAlerts).toHaveBeenCalledWith({ ids: [alerts[0].id, alerts[1].id], http });
+  });
+
+  it('enableAlerts calls the muteAlertss api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ enableAlerts, alerts }: ComponentOpts & { alerts: Alert[] }) => {
+      return <button onClick={() => enableAlerts(alerts)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alerts = [
+      mockAlert({ enabled: false }),
+      mockAlert({ enabled: true }),
+      mockAlert({ enabled: false }),
+    ];
+    const component = mount(<ExtendedComponent alerts={alerts} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.enableAlerts).toHaveBeenCalledTimes(1);
+    expect(alertApi.enableAlerts).toHaveBeenCalledWith({ ids: [alerts[0].id, alerts[2].id], http });
+  });
+
+  it('disableAlerts calls the disableAlerts api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ disableAlerts, alerts }: ComponentOpts & { alerts: Alert[] }) => {
+      return <button onClick={() => disableAlerts(alerts)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alerts = [mockAlert(), mockAlert()];
+    const component = mount(<ExtendedComponent alerts={alerts} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.disableAlerts).toHaveBeenCalledTimes(1);
+    expect(alertApi.disableAlerts).toHaveBeenCalledWith({
+      ids: [alerts[0].id, alerts[1].id],
+      http,
+    });
+  });
+
+  it('deleteAlerts calls the deleteAlerts api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ deleteAlerts, alerts }: ComponentOpts & { alerts: Alert[] }) => {
+      return <button onClick={() => deleteAlerts(alerts)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alerts = [mockAlert(), mockAlert()];
+    const component = mount(<ExtendedComponent alerts={alerts} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.deleteAlerts).toHaveBeenCalledTimes(1);
+    expect(alertApi.deleteAlerts).toHaveBeenCalledWith({ ids: [alerts[0].id, alerts[1].id], http });
+  });
+
+  it('loadAlert calls the loadAlert api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({
+      loadAlert,
+      alertId,
+    }: ComponentOpts & { alertId: Alert['id'] }) => {
+      return <button onClick={() => loadAlert(alertId)}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const alertId = uuid.v4();
+    const component = mount(<ExtendedComponent alertId={alertId} />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.loadAlert).toHaveBeenCalledTimes(1);
+    expect(alertApi.loadAlert).toHaveBeenCalledWith({ alertId, http });
+  });
+
+  it('loadAlertTypes calls the loadAlertTypes api', () => {
+    const { http } = useAppDependencies();
+    const ComponentToExtend = ({ loadAlertTypes }: ComponentOpts) => {
+      return <button onClick={() => loadAlertTypes()}>{'call api'}</button>;
+    };
+
+    const ExtendedComponent = withBulkAlertOperations(ComponentToExtend);
+    const component = mount(<ExtendedComponent />);
+    component.find('button').simulate('click');
+
+    expect(alertApi.loadAlertTypes).toHaveBeenCalledTimes(1);
+    expect(alertApi.loadAlertTypes).toHaveBeenCalledWith({ http });
+  });
+});
+
+function mockAlert(overloads: Partial<Alert> = {}): Alert {
+  return {
+    id: uuid.v4(),
+    enabled: true,
+    name: `alert-${uuid.v4()}`,
+    tags: [],
+    alertTypeId: '.noop',
+    consumer: 'consumer',
+    schedule: { interval: '1m' },
+    actions: [],
+    params: {},
+    createdBy: null,
+    updatedBy: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    apiKeyOwner: null,
+    throttle: null,
+    muteAll: false,
+    mutedInstanceIds: [],
+    ...overloads,
+  };
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.tsx b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.tsx
new file mode 100644
index 0000000000000..c61ba631ab868
--- /dev/null
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/application/sections/common/components/with_bulk_alert_api_operations.tsx
@@ -0,0 +1,103 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import React from 'react';
+
+import { Alert, AlertType } from '../../../../types';
+import { useAppDependencies } from '../../../app_context';
+import {
+  deleteAlerts,
+  disableAlerts,
+  enableAlerts,
+  muteAlerts,
+  unmuteAlerts,
+  deleteAlert,
+  disableAlert,
+  enableAlert,
+  muteAlert,
+  unmuteAlert,
+  loadAlert,
+  loadAlertTypes,
+} from '../../../lib/alert_api';
+
+export interface ComponentOpts {
+  muteAlerts: (alerts: Alert[]) => Promise<void>;
+  unmuteAlerts: (alerts: Alert[]) => Promise<void>;
+  enableAlerts: (alerts: Alert[]) => Promise<void>;
+  disableAlerts: (alerts: Alert[]) => Promise<void>;
+  deleteAlerts: (alerts: Alert[]) => Promise<void>;
+  muteAlert: (alert: Alert) => Promise<void>;
+  unmuteAlert: (alert: Alert) => Promise<void>;
+  enableAlert: (alert: Alert) => Promise<void>;
+  disableAlert: (alert: Alert) => Promise<void>;
+  deleteAlert: (alert: Alert) => Promise<void>;
+  loadAlert: (id: Alert['id']) => Promise<Alert>;
+  loadAlertTypes: () => Promise<AlertType[]>;
+}
+
+export type PropsWithOptionalApiHandlers<T> = Omit<T, keyof ComponentOpts> & Partial<ComponentOpts>;
+
+export function withBulkAlertOperations<T>(
+  WrappedComponent: React.ComponentType<T & ComponentOpts>
+): React.FunctionComponent<PropsWithOptionalApiHandlers<T>> {
+  return (props: PropsWithOptionalApiHandlers<T>) => {
+    const { http } = useAppDependencies();
+    return (
+      <WrappedComponent
+        {...(props as T)}
+        muteAlerts={async (items: Alert[]) =>
+          muteAlerts({ http, ids: items.filter(item => !isAlertMuted(item)).map(item => item.id) })
+        }
+        unmuteAlerts={async (items: Alert[]) =>
+          unmuteAlerts({ http, ids: items.filter(isAlertMuted).map(item => item.id) })
+        }
+        enableAlerts={async (items: Alert[]) =>
+          enableAlerts({ http, ids: items.filter(isAlertDisabled).map(item => item.id) })
+        }
+        disableAlerts={async (items: Alert[]) =>
+          disableAlerts({
+            http,
+            ids: items.filter(item => !isAlertDisabled(item)).map(item => item.id),
+          })
+        }
+        deleteAlerts={async (items: Alert[]) =>
+          deleteAlerts({ http, ids: items.map(item => item.id) })
+        }
+        muteAlert={async (alert: Alert) => {
+          if (!isAlertMuted(alert)) {
+            return muteAlert({ http, id: alert.id });
+          }
+        }}
+        unmuteAlert={async (alert: Alert) => {
+          if (isAlertMuted(alert)) {
+            return unmuteAlert({ http, id: alert.id });
+          }
+        }}
+        enableAlert={async (alert: Alert) => {
+          if (isAlertDisabled(alert)) {
+            return enableAlert({ http, id: alert.id });
+          }
+        }}
+        disableAlert={async (alert: Alert) => {
+          if (!isAlertDisabled(alert)) {
+            return disableAlert({ http, id: alert.id });
+          }
+        }}
+        deleteAlert={async (alert: Alert) => deleteAlert({ http, id: alert.id })}
+        loadAlert={async (alertId: Alert['id']) => loadAlert({ http, alertId })}
+        loadAlertTypes={async () => loadAlertTypes({ http })}
+      />
+    );
+  };
+}
+
+function isAlertDisabled(alert: Alert) {
+  return alert.enabled === false;
+}
+
+function isAlertMuted(alert: Alert) {
+  return alert.muteAll === true;
+}
diff --git a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/types.ts b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/types.ts
index ed63ade903104..7fb7d0bf48e4d 100644
--- a/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/types.ts
+++ b/x-pack/legacy/plugins/triggers_actions_ui/np_ready/public/types.ts
@@ -4,8 +4,11 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import { TypeRegistry } from './application/type_registry';
-import { SanitizedAlert as Alert } from '../../../alerting/common';
-export { SanitizedAlert as Alert, AlertAction } from '../../../alerting/common';
+import { SanitizedAlert as Alert, AlertAction } from '../../../alerting/common';
+import { ActionType } from '../../../../../plugins/actions/common';
+
+export { Alert, AlertAction };
+export { ActionType };
 
 export type ActionTypeIndex = Record<string, ActionType>;
 export type AlertTypeIndex = Record<string, AlertType>;
@@ -47,11 +50,6 @@ export interface ValidationResult {
   errors: Record<string, any>;
 }
 
-export interface ActionType {
-  id: string;
-  name: string;
-}
-
 export interface ActionConnector {
   secrets: Record<string, any>;
   id: string;
diff --git a/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/details.ts b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/details.ts
new file mode 100644
index 0000000000000..e8ed54571c77c
--- /dev/null
+++ b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/details.ts
@@ -0,0 +1,146 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import expect from '@kbn/expect';
+import uuid from 'uuid';
+import { FtrProviderContext } from '../../ftr_provider_context';
+
+export default ({ getPageObjects, getService }: FtrProviderContext) => {
+  const testSubjects = getService('testSubjects');
+  const pageObjects = getPageObjects(['common', 'triggersActionsUI', 'header', 'alertDetailsUI']);
+  const browser = getService('browser');
+  const alerting = getService('alerting');
+
+  describe('Alert Details', function() {
+    const testRunUuid = uuid.v4();
+
+    before(async () => {
+      await pageObjects.common.navigateToApp('triggersActions');
+
+      const actions = await Promise.all([
+        alerting.actions.createAction({
+          name: `server-log-${testRunUuid}-${0}`,
+          actionTypeId: '.server-log',
+          config: {},
+          secrets: {},
+        }),
+        alerting.actions.createAction({
+          name: `server-log-${testRunUuid}-${1}`,
+          actionTypeId: '.server-log',
+          config: {},
+          secrets: {},
+        }),
+      ]);
+
+      const alert = await alerting.alerts.createAlwaysFiringWithActions(
+        `test-alert-${testRunUuid}`,
+        actions.map(action => ({
+          id: action.id,
+          group: 'default',
+          params: {
+            message: 'from alert 1s',
+            level: 'warn',
+          },
+        }))
+      );
+
+      // refresh to see alert
+      await browser.refresh();
+
+      await pageObjects.header.waitUntilLoadingHasFinished();
+
+      // Verify content
+      await testSubjects.existOrFail('alertsList');
+
+      // click on first alert
+      await pageObjects.triggersActionsUI.clickOnAlertInAlertsList(alert.name);
+    });
+
+    it('renders the alert details', async () => {
+      const headingText = await pageObjects.alertDetailsUI.getHeadingText();
+      expect(headingText).to.be(`test-alert-${testRunUuid}`);
+
+      const alertType = await pageObjects.alertDetailsUI.getAlertType();
+      expect(alertType).to.be(`Always Firing`);
+
+      const { actionType, actionCount } = await pageObjects.alertDetailsUI.getActionsLabels();
+      expect(actionType).to.be(`Server log`);
+      expect(actionCount).to.be(`+1`);
+    });
+
+    it('should disable the alert', async () => {
+      const enableSwitch = await testSubjects.find('enableSwitch');
+
+      const isChecked = await enableSwitch.getAttribute('aria-checked');
+      expect(isChecked).to.eql('true');
+
+      await enableSwitch.click();
+
+      const enabledSwitchAfterDisabling = await testSubjects.find('enableSwitch');
+      const isCheckedAfterDisabling = await enabledSwitchAfterDisabling.getAttribute(
+        'aria-checked'
+      );
+      expect(isCheckedAfterDisabling).to.eql('false');
+    });
+
+    it('shouldnt allow you to mute a disabled alert', async () => {
+      const disabledEnableSwitch = await testSubjects.find('enableSwitch');
+      expect(await disabledEnableSwitch.getAttribute('aria-checked')).to.eql('false');
+
+      const muteSwitch = await testSubjects.find('muteSwitch');
+      expect(await muteSwitch.getAttribute('aria-checked')).to.eql('false');
+
+      await muteSwitch.click();
+
+      const muteSwitchAfterTryingToMute = await testSubjects.find('muteSwitch');
+      const isDisabledMuteAfterDisabling = await muteSwitchAfterTryingToMute.getAttribute(
+        'aria-checked'
+      );
+      expect(isDisabledMuteAfterDisabling).to.eql('false');
+    });
+
+    it('should reenable a disabled the alert', async () => {
+      const enableSwitch = await testSubjects.find('enableSwitch');
+
+      const isChecked = await enableSwitch.getAttribute('aria-checked');
+      expect(isChecked).to.eql('false');
+
+      await enableSwitch.click();
+
+      const enabledSwitchAfterReenabling = await testSubjects.find('enableSwitch');
+      const isCheckedAfterDisabling = await enabledSwitchAfterReenabling.getAttribute(
+        'aria-checked'
+      );
+      expect(isCheckedAfterDisabling).to.eql('true');
+    });
+
+    it('should mute the alert', async () => {
+      const muteSwitch = await testSubjects.find('muteSwitch');
+
+      const isChecked = await muteSwitch.getAttribute('aria-checked');
+      expect(isChecked).to.eql('false');
+
+      await muteSwitch.click();
+
+      const muteSwitchAfterDisabling = await testSubjects.find('muteSwitch');
+      const isCheckedAfterDisabling = await muteSwitchAfterDisabling.getAttribute('aria-checked');
+      expect(isCheckedAfterDisabling).to.eql('true');
+    });
+
+    it('should unmute the alert', async () => {
+      const muteSwitch = await testSubjects.find('muteSwitch');
+
+      const isChecked = await muteSwitch.getAttribute('aria-checked');
+      expect(isChecked).to.eql('true');
+
+      await muteSwitch.click();
+
+      const muteSwitchAfterUnmuting = await testSubjects.find('muteSwitch');
+      const isCheckedAfterDisabling = await muteSwitchAfterUnmuting.getAttribute('aria-checked');
+      expect(isCheckedAfterDisabling).to.eql('false');
+    });
+  });
+};
diff --git a/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/home_page.ts b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/home_page.ts
index 13f50a505b0b6..307f39382a236 100644
--- a/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/home_page.ts
+++ b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/home_page.ts
@@ -12,6 +12,7 @@ export default ({ getPageObjects, getService }: FtrProviderContext) => {
   const pageObjects = getPageObjects(['common', 'triggersActionsUI', 'header']);
   const log = getService('log');
   const browser = getService('browser');
+  const alerting = getService('alerting');
 
   describe('Home page', function() {
     before(async () => {
@@ -55,6 +56,43 @@ export default ({ getPageObjects, getService }: FtrProviderContext) => {
         // Verify content
         await testSubjects.existOrFail('alertsList');
       });
+
+      it('navigates to an alert details page', async () => {
+        const action = await alerting.actions.createAction({
+          name: `server-log-${Date.now()}`,
+          actionTypeId: '.server-log',
+          config: {},
+          secrets: {},
+        });
+
+        const alert = await alerting.alerts.createAlwaysFiringWithAction(
+          `test-alert-${Date.now()}`,
+          {
+            id: action.id,
+            group: 'default',
+            params: {
+              message: 'from alert 1s',
+              level: 'warn',
+            },
+          }
+        );
+
+        // refresh to see alert
+        await browser.refresh();
+
+        await pageObjects.header.waitUntilLoadingHasFinished();
+
+        // Verify content
+        await testSubjects.existOrFail('alertsList');
+
+        // click on first alert
+        await pageObjects.triggersActionsUI.clickOnAlertInAlertsList(alert.name);
+
+        // Verify url
+        expect(await browser.getCurrentUrl()).to.contain(`/alert/${alert.id}`);
+
+        await alerting.alerts.deleteAlert(alert.id);
+      });
     });
   });
 };
diff --git a/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/index.ts b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/index.ts
index c76f477c8cfbe..a771fbf85e0b6 100644
--- a/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/index.ts
+++ b/x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/index.ts
@@ -12,5 +12,6 @@ export default ({ loadTestFile, getService }: FtrProviderContext) => {
     loadTestFile(require.resolve('./home_page'));
     loadTestFile(require.resolve('./connectors'));
     loadTestFile(require.resolve('./alerts'));
+    loadTestFile(require.resolve('./details'));
   });
 };
diff --git a/x-pack/test/functional_with_es_ssl/fixtures/plugins/alerts/index.ts b/x-pack/test/functional_with_es_ssl/fixtures/plugins/alerts/index.ts
index df651c67c2c28..43162e9256370 100644
--- a/x-pack/test/functional_with_es_ssl/fixtures/plugins/alerts/index.ts
+++ b/x-pack/test/functional_with_es_ssl/fixtures/plugins/alerts/index.ts
@@ -12,13 +12,42 @@ export default function(kibana: any) {
     require: ['alerting'],
     name: 'alerts',
     init(server: any) {
-      const noopAlertType: AlertType = {
-        id: 'test.noop',
-        name: 'Test: Noop',
-        actionGroups: ['default'],
-        async executor() {},
-      };
-      server.plugins.alerting.setup.registerType(noopAlertType);
+      createNoopAlertType(server.plugins.alerting.setup);
+      createAlwaysFiringAlertType(server.plugins.alerting.setup);
     },
   });
 }
+
+function createNoopAlertType(setupContract: any) {
+  const noopAlertType: AlertType = {
+    id: 'test.noop',
+    name: 'Test: Noop',
+    actionGroups: ['default'],
+    async executor() {},
+  };
+  setupContract.registerType(noopAlertType);
+}
+
+function createAlwaysFiringAlertType(setupContract: any) {
+  // Alert types
+  const alwaysFiringAlertType: any = {
+    id: 'test.always-firing',
+    name: 'Always Firing',
+    actionGroups: ['default', 'other'],
+    async executor(alertExecutorOptions: any) {
+      const { services, state } = alertExecutorOptions;
+
+      services
+        .alertInstanceFactory('1')
+        .replaceState({ instanceStateValue: true })
+        .scheduleActions('default', {
+          instanceContextValue: true,
+        });
+      return {
+        globalStateValue: true,
+        groupInSeriesIndex: (state.groupInSeriesIndex || 0) + 1,
+      };
+    },
+  };
+  setupContract.registerType(alwaysFiringAlertType);
+}
diff --git a/x-pack/test/functional_with_es_ssl/page_objects/alert_details.ts b/x-pack/test/functional_with_es_ssl/page_objects/alert_details.ts
new file mode 100644
index 0000000000000..6d2038a6ba04c
--- /dev/null
+++ b/x-pack/test/functional_with_es_ssl/page_objects/alert_details.ts
@@ -0,0 +1,26 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { FtrProviderContext } from '../ftr_provider_context';
+
+export function AlertDetailsPageProvider({ getService }: FtrProviderContext) {
+  const testSubjects = getService('testSubjects');
+
+  return {
+    async getHeadingText() {
+      return await testSubjects.getVisibleText('alertDetailsTitle');
+    },
+    async getAlertType() {
+      return await testSubjects.getVisibleText('alertTypeLabel');
+    },
+    async getActionsLabels() {
+      return {
+        actionType: await testSubjects.getVisibleText('actionTypeLabel'),
+        actionCount: await testSubjects.getVisibleText('actionCountLabel'),
+      };
+    },
+  };
+}
diff --git a/x-pack/test/functional_with_es_ssl/page_objects/index.ts b/x-pack/test/functional_with_es_ssl/page_objects/index.ts
index a068ba7dfe81d..cfc44221a9c17 100644
--- a/x-pack/test/functional_with_es_ssl/page_objects/index.ts
+++ b/x-pack/test/functional_with_es_ssl/page_objects/index.ts
@@ -6,8 +6,10 @@
 
 import { pageObjects as xpackFunctionalPageObjects } from '../../functional/page_objects';
 import { TriggersActionsPageProvider } from './triggers_actions_ui_page';
+import { AlertDetailsPageProvider } from './alert_details';
 
 export const pageObjects = {
   ...xpackFunctionalPageObjects,
   triggersActionsUI: TriggersActionsPageProvider,
+  alertDetailsUI: AlertDetailsPageProvider,
 };
diff --git a/x-pack/test/functional_with_es_ssl/page_objects/triggers_actions_ui_page.ts b/x-pack/test/functional_with_es_ssl/page_objects/triggers_actions_ui_page.ts
index a04ecc969a7e1..ae66ac0ddddfb 100644
--- a/x-pack/test/functional_with_es_ssl/page_objects/triggers_actions_ui_page.ts
+++ b/x-pack/test/functional_with_es_ssl/page_objects/triggers_actions_ui_page.ts
@@ -92,6 +92,10 @@ export function TriggersActionsPageProvider({ getService }: FtrProviderContext)
           };
         });
     },
+    async clickOnAlertInAlertsList(name: string) {
+      await this.searchAlerts(name);
+      await find.clickDisplayedByCssSelector(`[data-test-subj="alertsList"] [title="${name}"]`);
+    },
     async changeTabs(tab: 'alertsTab' | 'connectorsTab') {
       return await testSubjects.click(tab);
     },
diff --git a/x-pack/test/functional_with_es_ssl/services/alerting/actions.ts b/x-pack/test/functional_with_es_ssl/services/alerting/actions.ts
new file mode 100644
index 0000000000000..9454a32757068
--- /dev/null
+++ b/x-pack/test/functional_with_es_ssl/services/alerting/actions.ts
@@ -0,0 +1,48 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import util from 'util';
+import { ToolingLog } from '@kbn/dev-utils';
+
+export class Actions {
+  private log: ToolingLog;
+  private axios: AxiosInstance;
+
+  constructor(url: string, log: ToolingLog) {
+    this.log = log;
+    this.axios = axios.create({
+      headers: { 'kbn-xsrf': 'x-pack/ftr/services/alerting/actions' },
+      baseURL: url,
+      maxRedirects: 0,
+      validateStatus: () => true, // we do our own validation below and throw better error messages
+    });
+  }
+
+  public async createAction(actionParams: {
+    name: string;
+    actionTypeId: string;
+    config: Record<string, any>;
+    secrets: Record<string, any>;
+  }) {
+    this.log.debug(`creating action ${actionParams.name}`);
+
+    const { data: action, status: actionStatus, actionStatusText } = await this.axios.post(
+      `/api/action`,
+      actionParams
+    );
+    if (actionStatus !== 200) {
+      throw new Error(
+        `Expected status code of 200, received ${actionStatus} ${actionStatusText}: ${util.inspect(
+          action
+        )}`
+      );
+    }
+
+    this.log.debug(`created action ${action.id}`);
+    return action;
+  }
+}
diff --git a/x-pack/test/functional_with_es_ssl/services/alerting/alerts.ts b/x-pack/test/functional_with_es_ssl/services/alerting/alerts.ts
new file mode 100644
index 0000000000000..1a31d4796d5bc
--- /dev/null
+++ b/x-pack/test/functional_with_es_ssl/services/alerting/alerts.ts
@@ -0,0 +1,79 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import util from 'util';
+import { ToolingLog } from '@kbn/dev-utils';
+
+export class Alerts {
+  private log: ToolingLog;
+  private axios: AxiosInstance;
+
+  constructor(url: string, log: ToolingLog) {
+    this.log = log;
+    this.axios = axios.create({
+      headers: { 'kbn-xsrf': 'x-pack/ftr/services/alerting/alerts' },
+      baseURL: url,
+      maxRedirects: 0,
+      validateStatus: () => true, // we do our own validation below and throw better error messages
+    });
+  }
+
+  public async createAlwaysFiringWithActions(
+    name: string,
+    actions: Array<{
+      id: string;
+      group: string;
+      params: Record<string, any>;
+    }>
+  ) {
+    this.log.debug(`creating alert ${name}`);
+
+    const { data: alert, status, statusText } = await this.axios.post(`/api/alert`, {
+      enabled: true,
+      name,
+      tags: ['foo'],
+      alertTypeId: 'test.always-firing',
+      consumer: 'bar',
+      schedule: { interval: '1m' },
+      throttle: '1m',
+      actions,
+      params: {},
+    });
+    if (status !== 200) {
+      throw new Error(
+        `Expected status code of 200, received ${status} ${statusText}: ${util.inspect(alert)}`
+      );
+    }
+
+    this.log.debug(`created alert ${alert.id}`);
+
+    return alert;
+  }
+
+  public async createAlwaysFiringWithAction(
+    name: string,
+    action: {
+      id: string;
+      group: string;
+      params: Record<string, any>;
+    }
+  ) {
+    return this.createAlwaysFiringWithActions(name, [action]);
+  }
+
+  public async deleteAlert(id: string) {
+    this.log.debug(`deleting alert ${id}`);
+
+    const { data: alert, status, statusText } = await this.axios.delete(`/api/alert/${id}`);
+    if (status !== 204) {
+      throw new Error(
+        `Expected status code of 204, received ${status} ${statusText}: ${util.inspect(alert)}`
+      );
+    }
+    this.log.debug(`deleted alert ${alert.id}`);
+  }
+}
diff --git a/x-pack/test/functional_with_es_ssl/services/alerting/index.ts b/x-pack/test/functional_with_es_ssl/services/alerting/index.ts
new file mode 100644
index 0000000000000..e0aa827316c01
--- /dev/null
+++ b/x-pack/test/functional_with_es_ssl/services/alerting/index.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { format as formatUrl } from 'url';
+
+import { Alerts } from './alerts';
+import { Actions } from './actions';
+import { FtrProviderContext } from '../../ftr_provider_context';
+
+export function AlertsServiceProvider({ getService }: FtrProviderContext) {
+  const log = getService('log');
+  const config = getService('config');
+  const url = formatUrl(config.get('servers.kibana'));
+
+  return new (class AlertingService {
+    actions = new Actions(url, log);
+    alerts = new Alerts(url, log);
+  })();
+}
diff --git a/x-pack/test/functional_with_es_ssl/services/index.ts b/x-pack/test/functional_with_es_ssl/services/index.ts
index 6e96921c25a31..f04c2c980055d 100644
--- a/x-pack/test/functional_with_es_ssl/services/index.ts
+++ b/x-pack/test/functional_with_es_ssl/services/index.ts
@@ -5,7 +5,9 @@
  */
 
 import { services as xpackFunctionalServices } from '../../functional/services';
+import { AlertsServiceProvider } from './alerting';
 
 export const services = {
   ...xpackFunctionalServices,
+  alerting: AlertsServiceProvider,
 };

From 38dc1cbd3cb74baeb498978688c92683d42b974e Mon Sep 17 00:00:00 2001
From: Pierre Gayvallet <pierre.gayvallet@elastic.co>
Date: Mon, 3 Feb 2020 12:03:50 +0100
Subject: [PATCH 5/5] Migrate es-archiver to typescript (#56008)

* migrate lib/archives and lib/docs

* migrate lib/indices

* migrate end of /lib

* migrate /actions

* migrate es_archiver

* migrate cli

* migrate tests

* use proper log stub

* add Record typing

Co-authored-by: Elastic Machine <elasticmachine@users.noreply.github.com>
---
 .../lib/config/read_config_file.ts            |   2 +-
 src/es_archiver/actions/{edit.js => edit.ts}  |  13 +-
 ..._kibana_index.js => empty_kibana_index.ts} |  18 +-
 .../actions/{index.js => index.ts}            |   0
 src/es_archiver/actions/{load.js => load.ts}  |  29 +++-
 .../{rebuild_all.js => rebuild_all.ts}        |  21 ++-
 src/es_archiver/actions/{save.js => save.ts}  |  24 ++-
 .../actions/{unload.js => unload.ts}          |  22 ++-
 src/es_archiver/{cli.js => cli.ts}            |  22 +--
 src/es_archiver/es_archiver.d.ts              |  39 -----
 .../{es_archiver.js => es_archiver.ts}        |  33 ++--
 src/es_archiver/index.js                      |  20 ---
 src/es_archiver/{index.d.ts => index.ts}      |   0
 .../lib/__tests__/{stats.js => stats.ts}      |  18 +-
 .../__tests__/{format.js => format.ts}        |  16 +-
 .../archives/__tests__/{parse.js => parse.ts} |  20 +--
 .../archives/{constants.js => constants.ts}   |   0
 .../archives/{filenames.js => filenames.ts}   |   6 +-
 .../lib/archives/{format.js => format.ts}     |   4 +-
 .../lib/archives/{index.js => index.ts}       |   2 -
 .../lib/archives/{parse.js => parse.ts}       |   4 +-
 .../lib/{directory.js => directory.ts}        |   5 +-
 ...ream.js => generate_doc_records_stream.ts} |   2 +-
 ..._stream.js => index_doc_records_stream.ts} |   4 +-
 .../lib/docs/__tests__/{stubs.js => stubs.ts} |  29 +++-
 ...ream.js => generate_doc_records_stream.ts} |  19 ++-
 .../lib/docs/{index.js => index.ts}           |   0
 ..._stream.js => index_doc_records_stream.ts} |   9 +-
 src/es_archiver/lib/{index.js => index.ts}    |   2 +-
 ...index_stream.js => create_index_stream.ts} |  51 +++---
 ...index_stream.js => delete_index_stream.ts} |  29 ++--
 ...am.js => generate_index_records_stream.ts} |  14 +-
 .../lib/indices/__tests__/stubs.js            | 128 ---------------
 .../lib/indices/__tests__/stubs.ts            | 154 ++++++++++++++++++
 ...index_stream.js => create_index_stream.ts} |  35 +++-
 .../{delete_index.js => delete_index.ts}      |  34 ++--
 ...index_stream.js => delete_index_stream.ts} |  10 +-
 ...am.js => generate_index_records_stream.ts} |   8 +-
 .../lib/indices/{index.js => index.ts}        |   0
 .../{kibana_index.js => kibana_index.ts}      |  96 +++++++----
 ...rds_stream.js => filter_records_stream.ts} |   2 +-
 ...rds_stream.js => filter_records_stream.ts} |   4 +-
 .../lib/records/{index.js => index.ts}        |   0
 src/es_archiver/lib/stats.ts                  |   2 +
 src/legacy/utils/index.d.ts                   |  13 ++
 src/legacy/utils/streams/index.d.ts           |   6 +-
 46 files changed, 576 insertions(+), 393 deletions(-)
 rename src/es_archiver/actions/{edit.js => edit.ts} (91%)
 rename src/es_archiver/actions/{empty_kibana_index.js => empty_kibana_index.ts} (73%)
 rename src/es_archiver/actions/{index.js => index.ts} (100%)
 rename src/es_archiver/actions/{load.js => load.ts} (84%)
 rename src/es_archiver/actions/{rebuild_all.js => rebuild_all.ts} (84%)
 rename src/es_archiver/actions/{save.js => save.ts} (83%)
 rename src/es_archiver/actions/{unload.js => unload.ts} (79%)
 rename src/es_archiver/{cli.js => cli.ts} (90%)
 delete mode 100644 src/es_archiver/es_archiver.d.ts
 rename src/es_archiver/{es_archiver.js => es_archiver.ts} (83%)
 delete mode 100644 src/es_archiver/index.js
 rename src/es_archiver/{index.d.ts => index.ts} (100%)
 rename src/es_archiver/lib/__tests__/{stats.js => stats.ts} (95%)
 rename src/es_archiver/lib/archives/__tests__/{format.js => format.ts} (89%)
 rename src/es_archiver/lib/archives/__tests__/{parse.js => parse.ts} (93%)
 rename src/es_archiver/lib/archives/{constants.js => constants.ts} (100%)
 rename src/es_archiver/lib/archives/{filenames.js => filenames.ts} (91%)
 rename src/es_archiver/lib/archives/{format.js => format.ts} (93%)
 rename src/es_archiver/lib/archives/{index.js => index.ts} (99%)
 rename src/es_archiver/lib/archives/{parse.js => parse.ts} (91%)
 rename src/es_archiver/lib/{directory.js => directory.ts} (88%)
 rename src/es_archiver/lib/docs/__tests__/{generate_doc_records_stream.js => generate_doc_records_stream.ts} (98%)
 rename src/es_archiver/lib/docs/__tests__/{index_doc_records_stream.js => index_doc_records_stream.ts} (98%)
 rename src/es_archiver/lib/docs/__tests__/{stubs.js => stubs.ts} (74%)
 rename src/es_archiver/lib/docs/{generate_doc_records_stream.js => generate_doc_records_stream.ts} (80%)
 rename src/es_archiver/lib/docs/{index.js => index.ts} (100%)
 rename src/es_archiver/lib/docs/{index_doc_records_stream.js => index_doc_records_stream.ts} (86%)
 rename src/es_archiver/lib/{index.js => index.ts} (96%)
 rename src/es_archiver/lib/indices/__tests__/{create_index_stream.js => create_index_stream.ts} (76%)
 rename src/es_archiver/lib/indices/__tests__/{delete_index_stream.js => delete_index_stream.ts} (66%)
 rename src/es_archiver/lib/indices/__tests__/{generate_index_records_stream.js => generate_index_records_stream.ts} (89%)
 delete mode 100644 src/es_archiver/lib/indices/__tests__/stubs.js
 create mode 100644 src/es_archiver/lib/indices/__tests__/stubs.ts
 rename src/es_archiver/lib/indices/{create_index_stream.js => create_index_stream.ts} (81%)
 rename src/es_archiver/lib/indices/{delete_index.js => delete_index.ts} (76%)
 rename src/es_archiver/lib/indices/{delete_index_stream.js => delete_index_stream.ts} (86%)
 rename src/es_archiver/lib/indices/{generate_index_records_stream.js => generate_index_records_stream.ts} (89%)
 rename src/es_archiver/lib/indices/{index.js => index.ts} (100%)
 rename src/es_archiver/lib/indices/{kibana_index.js => kibana_index.ts} (70%)
 rename src/es_archiver/lib/records/__tests__/{filter_records_stream.js => filter_records_stream.ts} (97%)
 rename src/es_archiver/lib/records/{filter_records_stream.js => filter_records_stream.ts} (91%)
 rename src/es_archiver/lib/records/{index.js => index.ts} (100%)

diff --git a/packages/kbn-test/src/functional_test_runner/lib/config/read_config_file.ts b/packages/kbn-test/src/functional_test_runner/lib/config/read_config_file.ts
index 72926cae7dbc4..96fd525efa3ec 100644
--- a/packages/kbn-test/src/functional_test_runner/lib/config/read_config_file.ts
+++ b/packages/kbn-test/src/functional_test_runner/lib/config/read_config_file.ts
@@ -56,7 +56,7 @@ async function getSettingsFromFile(log: ToolingLog, path: string, settingOverrid
   return transformDeprecations(settingsWithDefaults, logDeprecation);
 }
 
-export async function readConfigFile(log: ToolingLog, path: string, settingOverrides: any) {
+export async function readConfigFile(log: ToolingLog, path: string, settingOverrides: any = {}) {
   return new Config({
     settings: await getSettingsFromFile(log, path, settingOverrides),
     primary: true,
diff --git a/src/es_archiver/actions/edit.js b/src/es_archiver/actions/edit.ts
similarity index 91%
rename from src/es_archiver/actions/edit.js
rename to src/es_archiver/actions/edit.ts
index 5e3a3490133c7..de63081a1ea1b 100644
--- a/src/es_archiver/actions/edit.js
+++ b/src/es_archiver/actions/edit.ts
@@ -22,12 +22,23 @@ import Fs from 'fs';
 import { createGunzip, createGzip, Z_BEST_COMPRESSION } from 'zlib';
 import { promisify } from 'util';
 import globby from 'globby';
+import { ToolingLog } from '@kbn/dev-utils';
 
 import { createPromiseFromStreams } from '../../legacy/utils';
 
 const unlinkAsync = promisify(Fs.unlink);
 
-export async function editAction({ prefix, dataDir, log, handler }) {
+export async function editAction({
+  prefix,
+  dataDir,
+  log,
+  handler,
+}: {
+  prefix: string;
+  dataDir: string;
+  log: ToolingLog;
+  handler: () => Promise<any>;
+}) {
   const archives = (
     await globby('**/*.gz', {
       cwd: prefix ? resolve(dataDir, prefix) : dataDir,
diff --git a/src/es_archiver/actions/empty_kibana_index.js b/src/es_archiver/actions/empty_kibana_index.ts
similarity index 73%
rename from src/es_archiver/actions/empty_kibana_index.js
rename to src/es_archiver/actions/empty_kibana_index.ts
index 386863ec18a43..5f96fbc5f996c 100644
--- a/src/es_archiver/actions/empty_kibana_index.js
+++ b/src/es_archiver/actions/empty_kibana_index.ts
@@ -16,13 +16,25 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
+import { Client } from 'elasticsearch';
+import { ToolingLog, KbnClient } from '@kbn/dev-utils';
+
 import { migrateKibanaIndex, deleteKibanaIndices, createStats } from '../lib';
 
-export async function emptyKibanaIndexAction({ client, log, kbnClient }) {
+export async function emptyKibanaIndexAction({
+  client,
+  log,
+  kbnClient,
+}: {
+  client: Client;
+  log: ToolingLog;
+  kbnClient: KbnClient;
+}) {
   const stats = createStats('emptyKibanaIndex', log);
   const kibanaPluginIds = await kbnClient.plugins.getEnabledIds();
 
-  await deleteKibanaIndices({ client, stats });
-  await migrateKibanaIndex({ client, log, stats, kibanaPluginIds });
+  await deleteKibanaIndices({ client, stats, log });
+  await migrateKibanaIndex({ client, log, kibanaPluginIds });
   return stats;
 }
diff --git a/src/es_archiver/actions/index.js b/src/es_archiver/actions/index.ts
similarity index 100%
rename from src/es_archiver/actions/index.js
rename to src/es_archiver/actions/index.ts
diff --git a/src/es_archiver/actions/load.js b/src/es_archiver/actions/load.ts
similarity index 84%
rename from src/es_archiver/actions/load.js
rename to src/es_archiver/actions/load.ts
index ea02ce9dd3ad3..404fd0daea91d 100644
--- a/src/es_archiver/actions/load.js
+++ b/src/es_archiver/actions/load.ts
@@ -19,6 +19,9 @@
 
 import { resolve } from 'path';
 import { createReadStream } from 'fs';
+import { Readable } from 'stream';
+import { ToolingLog, KbnClient } from '@kbn/dev-utils';
+import { Client } from 'elasticsearch';
 
 import { createPromiseFromStreams, concatStreamProviders } from '../../legacy/utils';
 
@@ -38,12 +41,26 @@ import {
 // pipe a series of streams into each other so that data and errors
 // flow from the first stream to the last. Errors from the last stream
 // are not listened for
-const pipeline = (...streams) =>
+const pipeline = (...streams: Readable[]) =>
   streams.reduce((source, dest) =>
-    source.once('error', error => dest.emit('error', error)).pipe(dest)
+    source.once('error', error => dest.emit('error', error)).pipe(dest as any)
   );
 
-export async function loadAction({ name, skipExisting, client, dataDir, log, kbnClient }) {
+export async function loadAction({
+  name,
+  skipExisting,
+  client,
+  dataDir,
+  log,
+  kbnClient,
+}: {
+  name: string;
+  skipExisting: boolean;
+  client: Client;
+  dataDir: string;
+  log: ToolingLog;
+  kbnClient: KbnClient;
+}) {
   const inputDir = resolve(dataDir, name);
   const stats = createStats(name, log);
   const files = prioritizeMappings(await readDirectory(inputDir));
@@ -64,12 +81,12 @@ export async function loadAction({ name, skipExisting, client, dataDir, log, kbn
     { objectMode: true }
   );
 
-  const progress = new Progress('load progress');
+  const progress = new Progress();
   progress.activate(log);
 
   await createPromiseFromStreams([
     recordStream,
-    createCreateIndexStream({ client, stats, skipExisting, log, kibanaPluginIds }),
+    createCreateIndexStream({ client, stats, skipExisting, log }),
     createIndexDocRecordsStream(client, stats, progress),
   ]);
 
@@ -77,7 +94,7 @@ export async function loadAction({ name, skipExisting, client, dataDir, log, kbn
   const result = stats.toJSON();
 
   for (const [index, { docs }] of Object.entries(result)) {
-    if (!docs && docs.indexed > 0) {
+    if (docs && docs.indexed > 0) {
       log.info('[%s] Indexed %d docs into %j', name, docs.indexed, index);
     }
   }
diff --git a/src/es_archiver/actions/rebuild_all.js b/src/es_archiver/actions/rebuild_all.ts
similarity index 84%
rename from src/es_archiver/actions/rebuild_all.js
rename to src/es_archiver/actions/rebuild_all.ts
index 9379a29c38130..1467a1d0430b7 100644
--- a/src/es_archiver/actions/rebuild_all.js
+++ b/src/es_archiver/actions/rebuild_all.ts
@@ -18,13 +18,12 @@
  */
 
 import { resolve, dirname, relative } from 'path';
-
 import { stat, rename, createReadStream, createWriteStream } from 'fs';
-
+import { Readable, Writable } from 'stream';
 import { fromNode } from 'bluebird';
+import { ToolingLog } from '@kbn/dev-utils';
 
 import { createPromiseFromStreams } from '../../legacy/utils';
-
 import {
   prioritizeMappings,
   readDirectory,
@@ -33,12 +32,20 @@ import {
   createFormatArchiveStreams,
 } from '../lib';
 
-async function isDirectory(path) {
+async function isDirectory(path: string): Promise<boolean> {
   const stats = await fromNode(cb => stat(path, cb));
   return stats.isDirectory();
 }
 
-export async function rebuildAllAction({ dataDir, log, rootDir = dataDir }) {
+export async function rebuildAllAction({
+  dataDir,
+  log,
+  rootDir = dataDir,
+}: {
+  dataDir: string;
+  log: ToolingLog;
+  rootDir?: string;
+}) {
   const childNames = prioritizeMappings(await readDirectory(dataDir));
   for (const childName of childNames) {
     const childPath = resolve(dataDir, childName);
@@ -58,11 +65,11 @@ export async function rebuildAllAction({ dataDir, log, rootDir = dataDir }) {
     const tempFile = childPath + (gzip ? '.rebuilding.gz' : '.rebuilding');
 
     await createPromiseFromStreams([
-      createReadStream(childPath),
+      createReadStream(childPath) as Readable,
       ...createParseArchiveStreams({ gzip }),
       ...createFormatArchiveStreams({ gzip }),
       createWriteStream(tempFile),
-    ]);
+    ] as [Readable, ...Writable[]]);
 
     await fromNode(cb => rename(tempFile, childPath, cb));
     log.info(`${archiveName} Rebuilt ${childName}`);
diff --git a/src/es_archiver/actions/save.js b/src/es_archiver/actions/save.ts
similarity index 83%
rename from src/es_archiver/actions/save.js
rename to src/es_archiver/actions/save.ts
index 2c264ed2ee3a9..7a3a9dd97c0ab 100644
--- a/src/es_archiver/actions/save.js
+++ b/src/es_archiver/actions/save.ts
@@ -19,9 +19,11 @@
 
 import { resolve } from 'path';
 import { createWriteStream, mkdirSync } from 'fs';
+import { Readable, Writable } from 'stream';
+import { Client } from 'elasticsearch';
+import { ToolingLog } from '@kbn/dev-utils';
 
 import { createListStream, createPromiseFromStreams } from '../../legacy/utils';
-
 import {
   createStats,
   createGenerateIndexRecordsStream,
@@ -30,7 +32,21 @@ import {
   Progress,
 } from '../lib';
 
-export async function saveAction({ name, indices, client, dataDir, log, raw }) {
+export async function saveAction({
+  name,
+  indices,
+  client,
+  dataDir,
+  log,
+  raw,
+}: {
+  name: string;
+  indices: string | string[];
+  client: Client;
+  dataDir: string;
+  log: ToolingLog;
+  raw: boolean;
+}) {
   const outputDir = resolve(dataDir, name);
   const stats = createStats(name, log);
 
@@ -48,7 +64,7 @@ export async function saveAction({ name, indices, client, dataDir, log, raw }) {
       createGenerateIndexRecordsStream(client, stats),
       ...createFormatArchiveStreams(),
       createWriteStream(resolve(outputDir, 'mappings.json')),
-    ]),
+    ] as [Readable, ...Writable[]]),
 
     // export all documents from matching indexes into data.json.gz
     createPromiseFromStreams([
@@ -56,7 +72,7 @@ export async function saveAction({ name, indices, client, dataDir, log, raw }) {
       createGenerateDocRecordsStream(client, stats, progress),
       ...createFormatArchiveStreams({ gzip: !raw }),
       createWriteStream(resolve(outputDir, `data.json${raw ? '' : '.gz'}`)),
-    ]),
+    ] as [Readable, ...Writable[]]),
   ]);
 
   progress.deactivate();
diff --git a/src/es_archiver/actions/unload.js b/src/es_archiver/actions/unload.ts
similarity index 79%
rename from src/es_archiver/actions/unload.js
rename to src/es_archiver/actions/unload.ts
index 2acf8d2d71986..130a6b542b218 100644
--- a/src/es_archiver/actions/unload.js
+++ b/src/es_archiver/actions/unload.ts
@@ -19,9 +19,11 @@
 
 import { resolve } from 'path';
 import { createReadStream } from 'fs';
+import { Readable, Writable } from 'stream';
+import { Client } from 'elasticsearch';
+import { ToolingLog, KbnClient } from '@kbn/dev-utils';
 
 import { createPromiseFromStreams } from '../../legacy/utils';
-
 import {
   isGzip,
   createStats,
@@ -32,7 +34,19 @@ import {
   createDeleteIndexStream,
 } from '../lib';
 
-export async function unloadAction({ name, client, dataDir, log, kbnClient }) {
+export async function unloadAction({
+  name,
+  client,
+  dataDir,
+  log,
+  kbnClient,
+}: {
+  name: string;
+  client: Client;
+  dataDir: string;
+  log: ToolingLog;
+  kbnClient: KbnClient;
+}) {
   const inputDir = resolve(dataDir, name);
   const stats = createStats(name, log);
   const kibanaPluginIds = await kbnClient.plugins.getEnabledIds();
@@ -42,11 +56,11 @@ export async function unloadAction({ name, client, dataDir, log, kbnClient }) {
     log.info('[%s] Unloading indices from %j', name, filename);
 
     await createPromiseFromStreams([
-      createReadStream(resolve(inputDir, filename)),
+      createReadStream(resolve(inputDir, filename)) as Readable,
       ...createParseArchiveStreams({ gzip: isGzip(filename) }),
       createFilterRecordsStream('index'),
       createDeleteIndexStream(client, stats, log, kibanaPluginIds),
-    ]);
+    ] as [Readable, ...Writable[]]);
   }
 
   return stats.toJSON();
diff --git a/src/es_archiver/cli.js b/src/es_archiver/cli.ts
similarity index 90%
rename from src/es_archiver/cli.js
rename to src/es_archiver/cli.ts
index 56d1fdca89780..252f99f8f47af 100644
--- a/src/es_archiver/cli.js
+++ b/src/es_archiver/cli.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-/*************************************************************
+/** ***********************************************************
  *
  *  Run `node scripts/es_archiver --help` for usage information
  *
@@ -27,17 +27,17 @@ import { resolve } from 'path';
 import { readFileSync } from 'fs';
 import { format as formatUrl } from 'url';
 import readline from 'readline';
-
 import { Command } from 'commander';
 import * as legacyElasticsearch from 'elasticsearch';
 
-import { EsArchiver } from './es_archiver';
 import { ToolingLog } from '@kbn/dev-utils';
 import { readConfigFile } from '@kbn/test';
 
+import { EsArchiver } from './es_archiver';
+
 const cmd = new Command('node scripts/es_archiver');
 
-const resolveConfigPath = v => resolve(process.cwd(), v);
+const resolveConfigPath = (v: string) => resolve(process.cwd(), v);
 const defaultConfigPath = resolveConfigPath('test/functional/config.js');
 
 cmd
@@ -56,6 +56,7 @@ cmd
     defaultConfigPath
   )
   .on('--help', () => {
+    // eslint-disable-next-line no-console
     console.log(readFileSync(resolve(__dirname, './cli_help.txt'), 'utf8'));
   });
 
@@ -95,10 +96,10 @@ cmd
           output: process.stdout,
         });
 
-        await new Promise(resolve => {
+        await new Promise(resolveInput => {
           rl.question(`Press enter when you're done`, () => {
             rl.close();
-            resolve();
+            resolveInput();
           });
         });
       })
@@ -112,12 +113,12 @@ cmd
 
 cmd.parse(process.argv);
 
-const missingCommand = cmd.args.every(a => !(a instanceof Command));
+const missingCommand = cmd.args.every(a => !((a as any) instanceof Command));
 if (missingCommand) {
   execute();
 }
 
-async function execute(fn) {
+async function execute(fn?: (esArchiver: EsArchiver, command: Command) => void): Promise<void> {
   try {
     const log = new ToolingLog({
       level: cmd.verbose ? 'debug' : 'info',
@@ -134,7 +135,7 @@ async function execute(fn) {
 
     // log and count all validation errors
     let errorCount = 0;
-    const error = msg => {
+    const error = (msg: string) => {
       errorCount++;
       log.error(msg);
     };
@@ -170,11 +171,12 @@ async function execute(fn) {
         dataDir: resolve(cmd.dir),
         kibanaUrl: cmd.kibanaUrl,
       });
-      await fn(esArchiver, cmd);
+      await fn!(esArchiver, cmd);
     } finally {
       await client.close();
     }
   } catch (err) {
+    // eslint-disable-next-line no-console
     console.log('FATAL ERROR', err.stack);
   }
 }
diff --git a/src/es_archiver/es_archiver.d.ts b/src/es_archiver/es_archiver.d.ts
deleted file mode 100644
index c50ae19d99cbf..0000000000000
--- a/src/es_archiver/es_archiver.d.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import { ToolingLog } from '@kbn/dev-utils';
-import { Client } from 'elasticsearch';
-import { createStats } from './lib/stats';
-
-export type JsonStats = ReturnType<ReturnType<typeof createStats>['toJSON']>;
-
-export class EsArchiver {
-  constructor(options: { client: Client; dataDir: string; log: ToolingLog; kibanaUrl: string });
-  public save(
-    name: string,
-    indices: string | string[],
-    options?: { raw?: boolean }
-  ): Promise<JsonStats>;
-  public load(name: string, options?: { skipExisting?: boolean }): Promise<JsonStats>;
-  public unload(name: string): Promise<JsonStats>;
-  public rebuildAll(): Promise<void>;
-  public edit(prefix: string, handler: () => Promise<void>): Promise<void>;
-  public loadIfNeeded(name: string): Promise<JsonStats>;
-  public emptyKibanaIndex(): Promise<JsonStats>;
-}
diff --git a/src/es_archiver/es_archiver.js b/src/es_archiver/es_archiver.ts
similarity index 83%
rename from src/es_archiver/es_archiver.js
rename to src/es_archiver/es_archiver.ts
index 705706d0e5877..5614dfd842087 100644
--- a/src/es_archiver/es_archiver.js
+++ b/src/es_archiver/es_archiver.ts
@@ -17,7 +17,8 @@
  * under the License.
  */
 
-import { KbnClient } from '@kbn/dev-utils';
+import { Client } from 'elasticsearch';
+import { ToolingLog, KbnClient } from '@kbn/dev-utils';
 
 import {
   saveAction,
@@ -29,7 +30,22 @@ import {
 } from './actions';
 
 export class EsArchiver {
-  constructor({ client, dataDir, log, kibanaUrl }) {
+  private readonly client: Client;
+  private readonly dataDir: string;
+  private readonly log: ToolingLog;
+  private readonly kbnClient: KbnClient;
+
+  constructor({
+    client,
+    dataDir,
+    log,
+    kibanaUrl,
+  }: {
+    client: Client;
+    dataDir: string;
+    log: ToolingLog;
+    kibanaUrl: string;
+  }) {
     this.client = client;
     this.dataDir = dataDir;
     this.log = log;
@@ -46,7 +62,7 @@ export class EsArchiver {
    *  @property {Boolean} options.raw - should the archive be raw (unzipped) or not
    *  @return Promise<Stats>
    */
-  async save(name, indices, { raw = false } = {}) {
+  async save(name: string, indices: string | string[], { raw = false }: { raw?: boolean } = {}) {
     return await saveAction({
       name,
       indices,
@@ -66,9 +82,7 @@ export class EsArchiver {
    *                                           be ignored or overwritten
    *  @return Promise<Stats>
    */
-  async load(name, options = {}) {
-    const { skipExisting } = options;
-
+  async load(name: string, { skipExisting = false }: { skipExisting?: boolean } = {}) {
     return await loadAction({
       name,
       skipExisting: !!skipExisting,
@@ -85,7 +99,7 @@ export class EsArchiver {
    *  @param {String} name
    *  @return Promise<Stats>
    */
-  async unload(name) {
+  async unload(name: string) {
     return await unloadAction({
       name,
       client: this.client,
@@ -103,7 +117,6 @@ export class EsArchiver {
    */
   async rebuildAll() {
     return await rebuildAllAction({
-      client: this.client,
       dataDir: this.dataDir,
       log: this.log,
     });
@@ -117,7 +130,7 @@ export class EsArchiver {
    *  @param {() => Promise<any>} handler
    *  @return Promise<void>
    */
-  async edit(prefix, handler) {
+  async edit(prefix: string, handler: () => Promise<void>) {
     return await editAction({
       prefix,
       log: this.log,
@@ -132,7 +145,7 @@ export class EsArchiver {
    *  @param {String} name
    *  @return Promise<Stats>
    */
-  async loadIfNeeded(name) {
+  async loadIfNeeded(name: string) {
     return await this.load(name, { skipExisting: true });
   }
 
diff --git a/src/es_archiver/index.js b/src/es_archiver/index.js
deleted file mode 100644
index f7a579a98a42d..0000000000000
--- a/src/es_archiver/index.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-export { EsArchiver } from './es_archiver';
diff --git a/src/es_archiver/index.d.ts b/src/es_archiver/index.ts
similarity index 100%
rename from src/es_archiver/index.d.ts
rename to src/es_archiver/index.ts
diff --git a/src/es_archiver/lib/__tests__/stats.js b/src/es_archiver/lib/__tests__/stats.ts
similarity index 95%
rename from src/es_archiver/lib/__tests__/stats.js
rename to src/es_archiver/lib/__tests__/stats.ts
index ccc24c25fb860..28e337b3da529 100644
--- a/src/es_archiver/lib/__tests__/stats.js
+++ b/src/es_archiver/lib/__tests__/stats.ts
@@ -17,26 +17,26 @@
  * under the License.
  */
 
-import expect from '@kbn/expect';
 import { uniq } from 'lodash';
 import sinon from 'sinon';
+import expect from '@kbn/expect';
+import { ToolingLog } from '@kbn/dev-utils';
 
 import { createStats } from '../';
-import { ToolingLog } from '@kbn/dev-utils';
 
-function createBufferedLog() {
-  const log = new ToolingLog({
+function createBufferedLog(): ToolingLog & { buffer: string } {
+  const log: ToolingLog = new ToolingLog({
     level: 'debug',
     writeTo: {
-      write: chunk => (log.buffer += chunk),
+      write: chunk => ((log as any).buffer += chunk),
     },
   });
-  log.buffer = '';
-  return log;
+  (log as any).buffer = '';
+  return log as ToolingLog & { buffer: string };
 }
 
-function assertDeepClones(a, b) {
-  const path = [];
+function assertDeepClones(a: any, b: any) {
+  const path: string[] = [];
   try {
     (function recurse(one, two) {
       if (typeof one !== 'object' || typeof two !== 'object') {
diff --git a/src/es_archiver/lib/archives/__tests__/format.js b/src/es_archiver/lib/archives/__tests__/format.ts
similarity index 89%
rename from src/es_archiver/lib/archives/__tests__/format.js
rename to src/es_archiver/lib/archives/__tests__/format.ts
index 20ead30824d06..f472f094134d7 100644
--- a/src/es_archiver/lib/archives/__tests__/format.js
+++ b/src/es_archiver/lib/archives/__tests__/format.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import Stream from 'stream';
+import Stream, { Readable, Writable } from 'stream';
 import { createGunzip } from 'zlib';
 
 import expect from '@kbn/expect';
@@ -43,11 +43,11 @@ describe('esArchiver createFormatArchiveStreams', () => {
     });
 
     it('streams consume js values and produces buffers', async () => {
-      const output = await createPromiseFromStreams([
+      const output = await createPromiseFromStreams<Buffer[]>([
         createListStream(INPUTS),
         ...createFormatArchiveStreams({ gzip: false }),
         createConcatStream([]),
-      ]);
+      ] as [Readable, ...Writable[]]);
 
       expect(output.length).to.be.greaterThan(0);
       output.forEach(b => expect(b).to.be.a(Buffer));
@@ -58,7 +58,7 @@ describe('esArchiver createFormatArchiveStreams', () => {
         createListStream(INPUTS),
         ...createFormatArchiveStreams({ gzip: false }),
         createConcatStream(''),
-      ]);
+      ] as [Readable, ...Writable[]]);
 
       expect(json).to.be(INPUT_JSON);
     });
@@ -73,11 +73,11 @@ describe('esArchiver createFormatArchiveStreams', () => {
     });
 
     it('streams consume js values and produces buffers', async () => {
-      const output = await createPromiseFromStreams([
+      const output = await createPromiseFromStreams<Buffer[]>([
         createListStream([1, 2, { foo: 'bar' }, [1, 2]]),
         ...createFormatArchiveStreams({ gzip: true }),
         createConcatStream([]),
-      ]);
+      ] as [Readable, ...Writable[]]);
 
       expect(output.length).to.be.greaterThan(0);
       output.forEach(b => expect(b).to.be.a(Buffer));
@@ -89,7 +89,7 @@ describe('esArchiver createFormatArchiveStreams', () => {
         ...createFormatArchiveStreams({ gzip: true }),
         createGunzip(),
         createConcatStream(''),
-      ]);
+      ] as [Readable, ...Writable[]]);
       expect(output).to.be(INPUT_JSON);
     });
   });
@@ -100,7 +100,7 @@ describe('esArchiver createFormatArchiveStreams', () => {
         createListStream(INPUTS),
         ...createFormatArchiveStreams(),
         createConcatStream(''),
-      ]);
+      ] as [Readable, ...Writable[]]);
 
       expect(json).to.be(INPUT_JSON);
     });
diff --git a/src/es_archiver/lib/archives/__tests__/parse.js b/src/es_archiver/lib/archives/__tests__/parse.ts
similarity index 93%
rename from src/es_archiver/lib/archives/__tests__/parse.js
rename to src/es_archiver/lib/archives/__tests__/parse.ts
index 2e1506e543a35..ba30156b5af39 100644
--- a/src/es_archiver/lib/archives/__tests__/parse.js
+++ b/src/es_archiver/lib/archives/__tests__/parse.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import Stream, { PassThrough, Transform } from 'stream';
+import Stream, { PassThrough, Readable, Writable, Transform } from 'stream';
 import { createGzip } from 'zlib';
 
 import expect from '@kbn/expect';
@@ -66,13 +66,13 @@ describe('esArchiver createParseArchiveStreams', () => {
           ]),
           ...createParseArchiveStreams({ gzip: false }),
           createConcatStream([]),
-        ]);
+        ] as [Readable, ...Writable[]]);
 
         expect(output).to.eql([{ a: 1 }, 1]);
       });
 
       it('provides each JSON object as soon as it is parsed', async () => {
-        let onReceived;
+        let onReceived: (resolved: any) => void;
         const receivedPromise = new Promise(resolve => (onReceived = resolve));
         const input = new PassThrough();
         const check = new Transform({
@@ -80,16 +80,16 @@ describe('esArchiver createParseArchiveStreams', () => {
           readableObjectMode: true,
           transform(chunk, env, callback) {
             onReceived(chunk);
-            callback(null, chunk);
+            callback(undefined, chunk);
           },
         });
 
         const finalPromise = createPromiseFromStreams([
-          input,
+          input as Readable,
           ...createParseArchiveStreams(),
           check,
           createConcatStream([]),
-        ]);
+        ] as [Readable, ...Writable[]]);
 
         input.write(Buffer.from('{"a": 1}\n\n{"a":'));
         expect(await receivedPromise).to.eql({ a: 1 });
@@ -110,7 +110,7 @@ describe('esArchiver createParseArchiveStreams', () => {
             ]),
             ...createParseArchiveStreams({ gzip: false }),
             createConcatStream(),
-          ]);
+          ] as [Readable, ...Writable[]]);
           throw new Error('should have failed');
         } catch (err) {
           expect(err.message).to.contain('Unexpected number');
@@ -149,7 +149,7 @@ describe('esArchiver createParseArchiveStreams', () => {
           createGzip(),
           ...createParseArchiveStreams({ gzip: true }),
           createConcatStream([]),
-        ]);
+        ] as [Readable, ...Writable[]]);
 
         expect(output).to.eql([{ a: 1 }, { a: 2 }]);
       });
@@ -161,7 +161,7 @@ describe('esArchiver createParseArchiveStreams', () => {
         createGzip(),
         ...createParseArchiveStreams({ gzip: true }),
         createConcatStream([]),
-      ]);
+      ] as [Readable, ...Writable[]]);
 
       expect(output).to.eql([]);
     });
@@ -173,7 +173,7 @@ describe('esArchiver createParseArchiveStreams', () => {
             createListStream([Buffer.from('{"a": 1}')]),
             ...createParseArchiveStreams({ gzip: true }),
             createConcatStream(),
-          ]);
+          ] as [Readable, ...Writable[]]);
           throw new Error('should have failed');
         } catch (err) {
           expect(err.message).to.contain('incorrect header check');
diff --git a/src/es_archiver/lib/archives/constants.js b/src/es_archiver/lib/archives/constants.ts
similarity index 100%
rename from src/es_archiver/lib/archives/constants.js
rename to src/es_archiver/lib/archives/constants.ts
diff --git a/src/es_archiver/lib/archives/filenames.js b/src/es_archiver/lib/archives/filenames.ts
similarity index 91%
rename from src/es_archiver/lib/archives/filenames.js
rename to src/es_archiver/lib/archives/filenames.ts
index 4ced04401d28d..24c355edda278 100644
--- a/src/es_archiver/lib/archives/filenames.js
+++ b/src/es_archiver/lib/archives/filenames.ts
@@ -19,7 +19,7 @@
 
 import { basename, extname } from 'path';
 
-export function isGzip(path) {
+export function isGzip(path: string) {
   return extname(path) === '.gz';
 }
 
@@ -28,7 +28,7 @@ export function isGzip(path) {
  *  @param  {String} path
  *  @return {Boolean}
  */
-export function isMappingFile(path) {
+export function isMappingFile(path: string) {
   return basename(path, '.gz') === 'mappings.json';
 }
 
@@ -41,7 +41,7 @@ export function isMappingFile(path) {
  *  @param {Array<String>} filenames
  *  @return {Array<String>}
  */
-export function prioritizeMappings(filenames) {
+export function prioritizeMappings(filenames: string[]) {
   return filenames.slice().sort((fa, fb) => {
     if (isMappingFile(fa) === isMappingFile(fb)) return 0;
     return isMappingFile(fb) ? 1 : -1;
diff --git a/src/es_archiver/lib/archives/format.js b/src/es_archiver/lib/archives/format.ts
similarity index 93%
rename from src/es_archiver/lib/archives/format.js
rename to src/es_archiver/lib/archives/format.ts
index 01fca87e7ba98..9bef4c9adbf05 100644
--- a/src/es_archiver/lib/archives/format.js
+++ b/src/es_archiver/lib/archives/format.ts
@@ -19,14 +19,12 @@
 
 import { createGzip, Z_BEST_COMPRESSION } from 'zlib';
 import { PassThrough } from 'stream';
-
 import stringify from 'json-stable-stringify';
 
 import { createMapStream, createIntersperseStream } from '../../../legacy/utils';
-
 import { RECORD_SEPARATOR } from './constants';
 
-export function createFormatArchiveStreams({ gzip = false } = {}) {
+export function createFormatArchiveStreams({ gzip = false }: { gzip?: boolean } = {}) {
   return [
     createMapStream(record => stringify(record, { space: '  ' })),
     createIntersperseStream(RECORD_SEPARATOR),
diff --git a/src/es_archiver/lib/archives/index.js b/src/es_archiver/lib/archives/index.ts
similarity index 99%
rename from src/es_archiver/lib/archives/index.js
rename to src/es_archiver/lib/archives/index.ts
index 4020f52e45a35..6aa489ea5a46d 100644
--- a/src/es_archiver/lib/archives/index.js
+++ b/src/es_archiver/lib/archives/index.ts
@@ -18,7 +18,5 @@
  */
 
 export { isGzip, prioritizeMappings } from './filenames';
-
 export { createParseArchiveStreams } from './parse';
-
 export { createFormatArchiveStreams } from './format';
diff --git a/src/es_archiver/lib/archives/parse.js b/src/es_archiver/lib/archives/parse.ts
similarity index 91%
rename from src/es_archiver/lib/archives/parse.js
rename to src/es_archiver/lib/archives/parse.ts
index 4fe1df7259229..0f4460c925019 100644
--- a/src/es_archiver/lib/archives/parse.js
+++ b/src/es_archiver/lib/archives/parse.ts
@@ -29,7 +29,7 @@ export function createParseArchiveStreams({ gzip = false } = {}) {
     gzip ? createGunzip() : new PassThrough(),
     createReplaceStream('\r\n', '\n'),
     createSplitStream(RECORD_SEPARATOR),
-    createFilterStream(l => l.match(/[^\s]/)),
-    createMapStream(json => JSON.parse(json.trim())),
+    createFilterStream<string>(l => !!l.match(/[^\s]/)),
+    createMapStream<string>(json => JSON.parse(json.trim())),
   ];
 }
diff --git a/src/es_archiver/lib/directory.js b/src/es_archiver/lib/directory.ts
similarity index 88%
rename from src/es_archiver/lib/directory.js
rename to src/es_archiver/lib/directory.ts
index 5aee10cfea65d..8581207fa795d 100644
--- a/src/es_archiver/lib/directory.js
+++ b/src/es_archiver/lib/directory.ts
@@ -18,10 +18,9 @@
  */
 
 import { readdir } from 'fs';
-
 import { fromNode } from 'bluebird';
 
-export async function readDirectory(path) {
-  const allNames = await fromNode(cb => readdir(path, cb));
+export async function readDirectory(path: string) {
+  const allNames = await fromNode<string[]>(cb => readdir(path, cb));
   return allNames.filter(name => !name.startsWith('.'));
 }
diff --git a/src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.js b/src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.ts
similarity index 98%
rename from src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.js
rename to src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.ts
index bf4aab208127f..03599cdc9fbcf 100644
--- a/src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.js
+++ b/src/es_archiver/lib/docs/__tests__/generate_doc_records_stream.ts
@@ -143,7 +143,7 @@ describe('esArchiver: createGenerateDocRecordsStream()', () => {
         },
       },
     ]);
-    sinon.assert.calledTwice(stats.archivedDoc);
+    sinon.assert.calledTwice(stats.archivedDoc as any);
     expect(progress.getTotal()).to.be(2);
     expect(progress.getComplete()).to.be(2);
   });
diff --git a/src/es_archiver/lib/docs/__tests__/index_doc_records_stream.js b/src/es_archiver/lib/docs/__tests__/index_doc_records_stream.ts
similarity index 98%
rename from src/es_archiver/lib/docs/__tests__/index_doc_records_stream.js
rename to src/es_archiver/lib/docs/__tests__/index_doc_records_stream.ts
index 2535642c27cc9..35b068a691090 100644
--- a/src/es_archiver/lib/docs/__tests__/index_doc_records_stream.js
+++ b/src/es_archiver/lib/docs/__tests__/index_doc_records_stream.ts
@@ -26,12 +26,12 @@ import { Progress } from '../../progress';
 import { createIndexDocRecordsStream } from '../index_doc_records_stream';
 import { createStubStats, createStubClient, createPersonDocRecords } from './stubs';
 
-const recordsToBulkBody = records => {
+const recordsToBulkBody = (records: any[]) => {
   return records.reduce((acc, record) => {
     const { index, id, source } = record.value;
 
     return [...acc, { index: { _index: index, _id: id } }, source];
-  }, []);
+  }, [] as any[]);
 };
 
 describe('esArchiver: createIndexDocRecordsStream()', () => {
diff --git a/src/es_archiver/lib/docs/__tests__/stubs.js b/src/es_archiver/lib/docs/__tests__/stubs.ts
similarity index 74%
rename from src/es_archiver/lib/docs/__tests__/stubs.js
rename to src/es_archiver/lib/docs/__tests__/stubs.ts
index 9ed48efa7d03a..698d62e450cb4 100644
--- a/src/es_archiver/lib/docs/__tests__/stubs.js
+++ b/src/es_archiver/lib/docs/__tests__/stubs.ts
@@ -17,17 +17,22 @@
  * under the License.
  */
 
+import { Client } from 'elasticsearch';
 import sinon from 'sinon';
 import Chance from 'chance';
 import { times } from 'lodash';
+
+import { Stats } from '../../stats';
+
 const chance = new Chance();
 
-export const createStubStats = () => ({
-  indexedDoc: sinon.stub(),
-  archivedDoc: sinon.stub(),
-});
+export const createStubStats = (): Stats =>
+  ({
+    indexedDoc: sinon.stub(),
+    archivedDoc: sinon.stub(),
+  } as any);
 
-export const createPersonDocRecords = n =>
+export const createPersonDocRecords = (n: number) =>
   times(n, () => ({
     type: 'doc',
     value: {
@@ -42,15 +47,21 @@ export const createPersonDocRecords = n =>
     },
   }));
 
-export const createStubClient = (responses = []) => {
-  const createStubClientMethod = name =>
+type MockClient = Client & {
+  assertNoPendingResponses: () => void;
+};
+
+export const createStubClient = (
+  responses: Array<(name: string, params: any) => any | Promise<any>> = []
+): MockClient => {
+  const createStubClientMethod = (name: string) =>
     sinon.spy(async params => {
       if (responses.length === 0) {
         throw new Error(`unexpected client.${name} call`);
       }
 
       const response = responses.shift();
-      return await response(name, params);
+      return await response!(name, params);
     });
 
   return {
@@ -63,5 +74,5 @@ export const createStubClient = (responses = []) => {
         throw new Error(`There are ${responses.length} unsent responses.`);
       }
     },
-  };
+  } as any;
 };
diff --git a/src/es_archiver/lib/docs/generate_doc_records_stream.js b/src/es_archiver/lib/docs/generate_doc_records_stream.ts
similarity index 80%
rename from src/es_archiver/lib/docs/generate_doc_records_stream.js
rename to src/es_archiver/lib/docs/generate_doc_records_stream.ts
index be8b0351d95c8..e255a0abc36c5 100644
--- a/src/es_archiver/lib/docs/generate_doc_records_stream.js
+++ b/src/es_archiver/lib/docs/generate_doc_records_stream.ts
@@ -18,33 +18,36 @@
  */
 
 import { Transform } from 'stream';
+import { Client, SearchParams, SearchResponse } from 'elasticsearch';
+import { Stats } from '../stats';
+import { Progress } from '../progress';
 
 const SCROLL_SIZE = 1000;
 const SCROLL_TIMEOUT = '1m';
 
-export function createGenerateDocRecordsStream(client, stats, progress) {
+export function createGenerateDocRecordsStream(client: Client, stats: Stats, progress: Progress) {
   return new Transform({
     writableObjectMode: true,
     readableObjectMode: true,
     async transform(index, enc, callback) {
       try {
-        let remainingHits = null;
-        let resp = null;
+        let remainingHits = 0;
+        let resp: SearchResponse<any> | null = null;
 
         while (!resp || remainingHits > 0) {
           if (!resp) {
             resp = await client.search({
-              index: index,
+              index,
               scroll: SCROLL_TIMEOUT,
               size: SCROLL_SIZE,
               _source: true,
-              rest_total_hits_as_int: true,
-            });
+              rest_total_hits_as_int: true, // not declared on SearchParams type
+            } as SearchParams);
             remainingHits = resp.hits.total;
             progress.addToTotal(remainingHits);
           } else {
             resp = await client.scroll({
-              scrollId: resp._scroll_id,
+              scrollId: resp._scroll_id!,
               scroll: SCROLL_TIMEOUT,
             });
           }
@@ -68,7 +71,7 @@ export function createGenerateDocRecordsStream(client, stats, progress) {
           progress.addToComplete(resp.hits.hits.length);
         }
 
-        callback(null);
+        callback(undefined);
       } catch (err) {
         callback(err);
       }
diff --git a/src/es_archiver/lib/docs/index.js b/src/es_archiver/lib/docs/index.ts
similarity index 100%
rename from src/es_archiver/lib/docs/index.js
rename to src/es_archiver/lib/docs/index.ts
diff --git a/src/es_archiver/lib/docs/index_doc_records_stream.js b/src/es_archiver/lib/docs/index_doc_records_stream.ts
similarity index 86%
rename from src/es_archiver/lib/docs/index_doc_records_stream.js
rename to src/es_archiver/lib/docs/index_doc_records_stream.ts
index 73fb75c52ff0a..8236ae8adb6db 100644
--- a/src/es_archiver/lib/docs/index_doc_records_stream.js
+++ b/src/es_archiver/lib/docs/index_doc_records_stream.ts
@@ -17,11 +17,14 @@
  * under the License.
  */
 
+import { Client } from 'elasticsearch';
 import { Writable } from 'stream';
+import { Stats } from '../stats';
+import { Progress } from '../progress';
 
-export function createIndexDocRecordsStream(client, stats, progress) {
-  async function indexDocs(docs) {
-    const body = [];
+export function createIndexDocRecordsStream(client: Client, stats: Stats, progress: Progress) {
+  async function indexDocs(docs: any[]) {
+    const body: any[] = [];
 
     docs.forEach(doc => {
       stats.indexedDoc(doc.index);
diff --git a/src/es_archiver/lib/index.js b/src/es_archiver/lib/index.ts
similarity index 96%
rename from src/es_archiver/lib/index.js
rename to src/es_archiver/lib/index.ts
index 246dd8169cd6b..960d51e411859 100644
--- a/src/es_archiver/lib/index.js
+++ b/src/es_archiver/lib/index.ts
@@ -30,7 +30,7 @@ export {
 
 export { createFilterRecordsStream } from './records';
 
-export { createStats } from './stats';
+export { createStats, Stats } from './stats';
 
 export {
   isGzip,
diff --git a/src/es_archiver/lib/indices/__tests__/create_index_stream.js b/src/es_archiver/lib/indices/__tests__/create_index_stream.ts
similarity index 76%
rename from src/es_archiver/lib/indices/__tests__/create_index_stream.js
rename to src/es_archiver/lib/indices/__tests__/create_index_stream.ts
index 9e0f83c9f7eb9..c90497eded88c 100644
--- a/src/es_archiver/lib/indices/__tests__/create_index_stream.js
+++ b/src/es_archiver/lib/indices/__tests__/create_index_stream.ts
@@ -34,10 +34,13 @@ import {
   createStubIndexRecord,
   createStubDocRecord,
   createStubClient,
+  createStubLogger,
 } from './stubs';
 
 const chance = new Chance();
 
+const log = createStubLogger();
+
 describe('esArchiver: createCreateIndexStream()', () => {
   describe('defaults', () => {
     it('deletes existing indices, creates all', async () => {
@@ -48,15 +51,15 @@ describe('esArchiver: createCreateIndexStream()', () => {
           createStubIndexRecord('existing-index'),
           createStubIndexRecord('new-index'),
         ]),
-        createCreateIndexStream({ client, stats }),
+        createCreateIndexStream({ client, stats, log }),
       ]);
 
       expect(stats.getTestSummary()).to.eql({
         deletedIndex: 1,
         createdIndex: 2,
       });
-      sinon.assert.callCount(client.indices.delete, 1);
-      sinon.assert.callCount(client.indices.create, 3); // one failed create because of existing
+      sinon.assert.callCount(client.indices.delete as sinon.SinonSpy, 1);
+      sinon.assert.callCount(client.indices.create as sinon.SinonSpy, 3); // one failed create because of existing
     });
 
     it('deletes existing aliases, creates all', async () => {
@@ -67,14 +70,19 @@ describe('esArchiver: createCreateIndexStream()', () => {
           createStubIndexRecord('existing-index'),
           createStubIndexRecord('new-index'),
         ]),
-        createCreateIndexStream({ client, stats, log: { debug: () => {} } }),
+        createCreateIndexStream({ client, stats, log }),
       ]);
 
-      expect(client.indices.getAlias.calledOnce).to.be.ok();
-      expect(client.indices.getAlias.args[0][0]).to.eql({ name: 'existing-index', ignore: [404] });
-      expect(client.indices.delete.calledOnce).to.be.ok();
-      expect(client.indices.delete.args[0][0]).to.eql({ index: ['actual-index'] });
-      sinon.assert.callCount(client.indices.create, 3); // one failed create because of existing
+      expect((client.indices.getAlias as sinon.SinonSpy).calledOnce).to.be.ok();
+      expect((client.indices.getAlias as sinon.SinonSpy).args[0][0]).to.eql({
+        name: 'existing-index',
+        ignore: [404],
+      });
+      expect((client.indices.delete as sinon.SinonSpy).calledOnce).to.be.ok();
+      expect((client.indices.delete as sinon.SinonSpy).args[0][0]).to.eql({
+        index: ['actual-index'],
+      });
+      sinon.assert.callCount(client.indices.create as sinon.SinonSpy, 3); // one failed create because of existing
     });
 
     it('passes through "hit" records', async () => {
@@ -86,7 +94,7 @@ describe('esArchiver: createCreateIndexStream()', () => {
           createStubDocRecord('index', 1),
           createStubDocRecord('index', 2),
         ]),
-        createCreateIndexStream({ client, stats }),
+        createCreateIndexStream({ client, stats, log }),
         createConcatStream([]),
       ]);
 
@@ -101,11 +109,11 @@ describe('esArchiver: createCreateIndexStream()', () => {
           createStubIndexRecord('index', { foo: {} }),
           createStubDocRecord('index', 1),
         ]),
-        createCreateIndexStream({ client, stats }),
+        createCreateIndexStream({ client, stats, log }),
         createConcatStream([]),
       ]);
 
-      sinon.assert.calledWith(client.indices.create, {
+      sinon.assert.calledWith(client.indices.create as sinon.SinonSpy, {
         method: 'PUT',
         index: 'index',
         body: {
@@ -126,7 +134,7 @@ describe('esArchiver: createCreateIndexStream()', () => {
 
       const output = await createPromiseFromStreams([
         createListStream([createStubIndexRecord('index'), ...randoms]),
-        createCreateIndexStream({ client, stats }),
+        createCreateIndexStream({ client, stats, log }),
         createConcatStream([]),
       ]);
 
@@ -140,7 +148,7 @@ describe('esArchiver: createCreateIndexStream()', () => {
 
       const output = await createPromiseFromStreams([
         createListStream(nonRecordValues),
-        createCreateIndexStream({ client, stats }),
+        createCreateIndexStream({ client, stats, log }),
         createConcatStream([]),
       ]);
 
@@ -161,6 +169,7 @@ describe('esArchiver: createCreateIndexStream()', () => {
         createCreateIndexStream({
           client,
           stats,
+          log,
           skipExisting: true,
         }),
       ]);
@@ -169,9 +178,12 @@ describe('esArchiver: createCreateIndexStream()', () => {
         skippedIndex: 1,
         createdIndex: 1,
       });
-      sinon.assert.callCount(client.indices.delete, 0);
-      sinon.assert.callCount(client.indices.create, 2); // one failed create because of existing
-      expect(client.indices.create.args[0][0]).to.have.property('index', 'new-index');
+      sinon.assert.callCount(client.indices.delete as sinon.SinonSpy, 0);
+      sinon.assert.callCount(client.indices.create as sinon.SinonSpy, 2); // one failed create because of existing
+      expect((client.indices.create as sinon.SinonSpy).args[0][0]).to.have.property(
+        'index',
+        'new-index'
+      );
     });
 
     it('filters documents for skipped indices', async () => {
@@ -190,6 +202,7 @@ describe('esArchiver: createCreateIndexStream()', () => {
         createCreateIndexStream({
           client,
           stats,
+          log,
           skipExisting: true,
         }),
         createConcatStream([]),
@@ -199,8 +212,8 @@ describe('esArchiver: createCreateIndexStream()', () => {
         skippedIndex: 1,
         createdIndex: 1,
       });
-      sinon.assert.callCount(client.indices.delete, 0);
-      sinon.assert.callCount(client.indices.create, 2); // one failed create because of existing
+      sinon.assert.callCount(client.indices.delete as sinon.SinonSpy, 0);
+      sinon.assert.callCount(client.indices.create as sinon.SinonSpy, 2); // one failed create because of existing
 
       expect(output).to.have.length(2);
       expect(output).to.eql([
diff --git a/src/es_archiver/lib/indices/__tests__/delete_index_stream.js b/src/es_archiver/lib/indices/__tests__/delete_index_stream.ts
similarity index 66%
rename from src/es_archiver/lib/indices/__tests__/delete_index_stream.js
rename to src/es_archiver/lib/indices/__tests__/delete_index_stream.ts
index 955d1fff8779e..1c989ba158a29 100644
--- a/src/es_archiver/lib/indices/__tests__/delete_index_stream.js
+++ b/src/es_archiver/lib/indices/__tests__/delete_index_stream.ts
@@ -23,7 +23,14 @@ import { createListStream, createPromiseFromStreams } from '../../../../legacy/u
 
 import { createDeleteIndexStream } from '../delete_index_stream';
 
-import { createStubStats, createStubClient, createStubIndexRecord } from './stubs';
+import {
+  createStubStats,
+  createStubClient,
+  createStubIndexRecord,
+  createStubLogger,
+} from './stubs';
+
+const log = createStubLogger();
 
 describe('esArchiver: createDeleteIndexStream()', () => {
   it('deletes the index without checking if it exists', async () => {
@@ -32,13 +39,13 @@ describe('esArchiver: createDeleteIndexStream()', () => {
 
     await createPromiseFromStreams([
       createListStream([createStubIndexRecord('index1')]),
-      createDeleteIndexStream(client, stats),
+      createDeleteIndexStream(client, stats, log, []),
     ]);
 
-    sinon.assert.notCalled(stats.deletedIndex);
-    sinon.assert.notCalled(client.indices.create);
-    sinon.assert.calledOnce(client.indices.delete);
-    sinon.assert.notCalled(client.indices.exists);
+    sinon.assert.notCalled(stats.deletedIndex as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.create as sinon.SinonSpy);
+    sinon.assert.calledOnce(client.indices.delete as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.exists as sinon.SinonSpy);
   });
 
   it('reports the delete when the index existed', async () => {
@@ -47,12 +54,12 @@ describe('esArchiver: createDeleteIndexStream()', () => {
 
     await createPromiseFromStreams([
       createListStream([createStubIndexRecord('index1')]),
-      createDeleteIndexStream(client, stats),
+      createDeleteIndexStream(client, stats, log, []),
     ]);
 
-    sinon.assert.calledOnce(stats.deletedIndex);
-    sinon.assert.notCalled(client.indices.create);
-    sinon.assert.calledOnce(client.indices.delete);
-    sinon.assert.notCalled(client.indices.exists);
+    sinon.assert.calledOnce(stats.deletedIndex as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.create as sinon.SinonSpy);
+    sinon.assert.calledOnce(client.indices.delete as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.exists as sinon.SinonSpy);
   });
 });
diff --git a/src/es_archiver/lib/indices/__tests__/generate_index_records_stream.js b/src/es_archiver/lib/indices/__tests__/generate_index_records_stream.ts
similarity index 89%
rename from src/es_archiver/lib/indices/__tests__/generate_index_records_stream.js
rename to src/es_archiver/lib/indices/__tests__/generate_index_records_stream.ts
index 3523e9e82b153..7a3712ca1a336 100644
--- a/src/es_archiver/lib/indices/__tests__/generate_index_records_stream.js
+++ b/src/es_archiver/lib/indices/__tests__/generate_index_records_stream.ts
@@ -45,10 +45,10 @@ describe('esArchiver: createGenerateIndexRecordsStream()', () => {
       archivedIndex: 4,
     });
 
-    sinon.assert.callCount(client.indices.get, 4);
-    sinon.assert.notCalled(client.indices.create);
-    sinon.assert.notCalled(client.indices.delete);
-    sinon.assert.notCalled(client.indices.exists);
+    sinon.assert.callCount(client.indices.get as sinon.SinonSpy, 4);
+    sinon.assert.notCalled(client.indices.create as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.delete as sinon.SinonSpy);
+    sinon.assert.notCalled(client.indices.exists as sinon.SinonSpy);
   });
 
   it('filters index metadata from settings', async () => {
@@ -60,9 +60,9 @@ describe('esArchiver: createGenerateIndexRecordsStream()', () => {
       createGenerateIndexRecordsStream(client, stats),
     ]);
 
-    const params = client.indices.get.args[0][0];
+    const params = (client.indices.get as sinon.SinonSpy).args[0][0];
     expect(params).to.have.property('filterPath');
-    const filters = params.filterPath;
+    const filters: string[] = params.filterPath;
     expect(filters.some(path => path.includes('index.creation_date'))).to.be(true);
     expect(filters.some(path => path.includes('index.uuid'))).to.be(true);
     expect(filters.some(path => path.includes('index.version'))).to.be(true);
@@ -73,7 +73,7 @@ describe('esArchiver: createGenerateIndexRecordsStream()', () => {
     const stats = createStubStats();
     const client = createStubClient(['index1', 'index2', 'index3']);
 
-    const indexRecords = await createPromiseFromStreams([
+    const indexRecords = await createPromiseFromStreams<any[]>([
       createListStream(['index1', 'index2', 'index3']),
       createGenerateIndexRecordsStream(client, stats),
       createConcatStream([]),
diff --git a/src/es_archiver/lib/indices/__tests__/stubs.js b/src/es_archiver/lib/indices/__tests__/stubs.js
deleted file mode 100644
index 00649a06f9efe..0000000000000
--- a/src/es_archiver/lib/indices/__tests__/stubs.js
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import sinon from 'sinon';
-
-export const createStubStats = () => ({
-  createdIndex: sinon.stub(),
-  createdAliases: sinon.stub(),
-  deletedIndex: sinon.stub(),
-  skippedIndex: sinon.stub(),
-  archivedIndex: sinon.stub(),
-  getTestSummary() {
-    const summary = {};
-    Object.keys(this).forEach(key => {
-      if (this[key].callCount) {
-        summary[key] = this[key].callCount;
-      }
-    });
-    return summary;
-  },
-});
-
-export const createStubIndexRecord = (index, aliases = {}) => ({
-  type: 'index',
-  value: { index, aliases },
-});
-
-export const createStubDocRecord = (index, id) => ({
-  type: 'doc',
-  value: { index, id },
-});
-
-const createEsClientError = errorType => {
-  const err = new Error(`ES Client Error Stub "${errorType}"`);
-  err.body = {
-    error: {
-      type: errorType,
-    },
-  };
-  return err;
-};
-
-const indexAlias = (aliases, index) => Object.keys(aliases).find(k => aliases[k] === index);
-
-export const createStubClient = (existingIndices = [], aliases = {}) => ({
-  indices: {
-    get: sinon.spy(async ({ index }) => {
-      if (!existingIndices.includes(index)) {
-        throw createEsClientError('index_not_found_exception');
-      }
-
-      return {
-        [index]: {
-          mappings: {},
-          settings: {},
-        },
-      };
-    }),
-    existsAlias: sinon.spy(({ name }) => {
-      return Promise.resolve(aliases.hasOwnProperty(name));
-    }),
-    getAlias: sinon.spy(async ({ index, name }) => {
-      if (index && existingIndices.indexOf(index) >= 0) {
-        const result = indexAlias(aliases, index);
-        return { [index]: { aliases: result ? { [result]: {} } : {} } };
-      }
-
-      if (name && aliases[name]) {
-        return { [aliases[name]]: { aliases: { [name]: {} } } };
-      }
-
-      return { status: 404 };
-    }),
-    updateAliases: sinon.spy(async ({ body }) => {
-      body.actions.forEach(({ add: { index, alias } }) => {
-        if (!existingIndices.includes(index)) {
-          throw createEsClientError('index_not_found_exception');
-        }
-        existingIndices.push({ index, alias });
-      });
-
-      return { ok: true };
-    }),
-    create: sinon.spy(async ({ index }) => {
-      if (existingIndices.includes(index) || aliases.hasOwnProperty(index)) {
-        throw createEsClientError('resource_already_exists_exception');
-      } else {
-        existingIndices.push(index);
-        return { ok: true };
-      }
-    }),
-    delete: sinon.spy(async ({ index }) => {
-      const indices = Array.isArray(index) ? index : [index];
-      if (indices.every(ix => existingIndices.includes(ix))) {
-        // Delete aliases associated with our indices
-        indices.forEach(ix => {
-          const alias = Object.keys(aliases).find(k => aliases[k] === ix);
-          if (alias) {
-            delete aliases[alias];
-          }
-        });
-        indices.forEach(ix => existingIndices.splice(existingIndices.indexOf(ix), 1));
-        return { ok: true };
-      } else {
-        throw createEsClientError('index_not_found_exception');
-      }
-    }),
-    exists: sinon.spy(async () => {
-      throw new Error('Do not use indices.exists(). React to errors instead.');
-    }),
-  },
-});
diff --git a/src/es_archiver/lib/indices/__tests__/stubs.ts b/src/es_archiver/lib/indices/__tests__/stubs.ts
new file mode 100644
index 0000000000000..3f4682299c38d
--- /dev/null
+++ b/src/es_archiver/lib/indices/__tests__/stubs.ts
@@ -0,0 +1,154 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { Client } from 'elasticsearch';
+import sinon from 'sinon';
+import { ToolingLog } from '@kbn/dev-utils';
+import { Stats } from '../../stats';
+
+type StubStats = Stats & {
+  getTestSummary: () => Record<string, number>;
+};
+
+export const createStubStats = (): StubStats =>
+  ({
+    createdIndex: sinon.stub(),
+    createdAliases: sinon.stub(),
+    deletedIndex: sinon.stub(),
+    skippedIndex: sinon.stub(),
+    archivedIndex: sinon.stub(),
+    getTestSummary() {
+      const summary: Record<string, number> = {};
+      Object.keys(this).forEach(key => {
+        if (this[key].callCount) {
+          summary[key] = this[key].callCount;
+        }
+      });
+      return summary;
+    },
+  } as any);
+
+export const createStubLogger = (): ToolingLog =>
+  ({
+    debug: sinon.stub(),
+    info: sinon.stub(),
+    success: sinon.stub(),
+    warning: sinon.stub(),
+    error: sinon.stub(),
+  } as any);
+
+export const createStubIndexRecord = (index: string, aliases = {}) => ({
+  type: 'index',
+  value: { index, aliases },
+});
+
+export const createStubDocRecord = (index: string, id: number) => ({
+  type: 'doc',
+  value: { index, id },
+});
+
+const createEsClientError = (errorType: string) => {
+  const err = new Error(`ES Client Error Stub "${errorType}"`);
+  (err as any).body = {
+    error: {
+      type: errorType,
+    },
+  };
+  return err;
+};
+
+const indexAlias = (aliases: Record<string, any>, index: string) =>
+  Object.keys(aliases).find(k => aliases[k] === index);
+
+type StubClient = Client;
+
+export const createStubClient = (
+  existingIndices: string[] = [],
+  aliases: Record<string, any> = {}
+): StubClient =>
+  ({
+    indices: {
+      get: sinon.spy(async ({ index }) => {
+        if (!existingIndices.includes(index)) {
+          throw createEsClientError('index_not_found_exception');
+        }
+
+        return {
+          [index]: {
+            mappings: {},
+            settings: {},
+          },
+        };
+      }),
+      existsAlias: sinon.spy(({ name }) => {
+        return Promise.resolve(aliases.hasOwnProperty(name));
+      }),
+      getAlias: sinon.spy(async ({ index, name }) => {
+        if (index && existingIndices.indexOf(index) >= 0) {
+          const result = indexAlias(aliases, index);
+          return { [index]: { aliases: result ? { [result]: {} } : {} } };
+        }
+
+        if (name && aliases[name]) {
+          return { [aliases[name]]: { aliases: { [name]: {} } } };
+        }
+
+        return { status: 404 };
+      }),
+      updateAliases: sinon.spy(async ({ body }) => {
+        body.actions.forEach(
+          ({ add: { index, alias } }: { add: { index: string; alias: string } }) => {
+            if (!existingIndices.includes(index)) {
+              throw createEsClientError('index_not_found_exception');
+            }
+            existingIndices.push({ index, alias } as any);
+          }
+        );
+
+        return { ok: true };
+      }),
+      create: sinon.spy(async ({ index }) => {
+        if (existingIndices.includes(index) || aliases.hasOwnProperty(index)) {
+          throw createEsClientError('resource_already_exists_exception');
+        } else {
+          existingIndices.push(index);
+          return { ok: true };
+        }
+      }),
+      delete: sinon.spy(async ({ index }) => {
+        const indices = Array.isArray(index) ? index : [index];
+        if (indices.every(ix => existingIndices.includes(ix))) {
+          // Delete aliases associated with our indices
+          indices.forEach(ix => {
+            const alias = Object.keys(aliases).find(k => aliases[k] === ix);
+            if (alias) {
+              delete aliases[alias];
+            }
+          });
+          indices.forEach(ix => existingIndices.splice(existingIndices.indexOf(ix), 1));
+          return { ok: true };
+        } else {
+          throw createEsClientError('index_not_found_exception');
+        }
+      }),
+      exists: sinon.spy(async () => {
+        throw new Error('Do not use indices.exists(). React to errors instead.');
+      }),
+    },
+  } as any);
diff --git a/src/es_archiver/lib/indices/create_index_stream.js b/src/es_archiver/lib/indices/create_index_stream.ts
similarity index 81%
rename from src/es_archiver/lib/indices/create_index_stream.js
rename to src/es_archiver/lib/indices/create_index_stream.ts
index 8fe4bc568cd23..df9d3bb623ad6 100644
--- a/src/es_archiver/lib/indices/create_index_stream.js
+++ b/src/es_archiver/lib/indices/create_index_stream.ts
@@ -17,13 +17,36 @@
  * under the License.
  */
 
-import { Transform } from 'stream';
-
+import { Transform, Readable } from 'stream';
 import { get, once } from 'lodash';
+import { Client } from 'elasticsearch';
+import { ToolingLog } from '@kbn/dev-utils';
+
+import { Stats } from '../stats';
 import { deleteKibanaIndices } from './kibana_index';
 import { deleteIndex } from './delete_index';
 
-export function createCreateIndexStream({ client, stats, skipExisting, log }) {
+interface DocRecord {
+  value: {
+    index: string;
+    type: string;
+    settings: Record<string, any>;
+    mappings: Record<string, any>;
+    aliases: Record<string, any>;
+  };
+}
+
+export function createCreateIndexStream({
+  client,
+  stats,
+  skipExisting = false,
+  log,
+}: {
+  client: Client;
+  stats: Stats;
+  skipExisting?: boolean;
+  log: ToolingLog;
+}) {
   const skipDocsFromIndices = new Set();
 
   // If we're trying to import Kibana index docs, we need to ensure that
@@ -31,7 +54,7 @@ export function createCreateIndexStream({ client, stats, skipExisting, log }) {
   // migrations. This only needs to be done once per archive load operation.
   const deleteKibanaIndicesOnce = once(deleteKibanaIndices);
 
-  async function handleDoc(stream, record) {
+  async function handleDoc(stream: Readable, record: DocRecord) {
     if (skipDocsFromIndices.has(record.value.index)) {
       return;
     }
@@ -39,7 +62,7 @@ export function createCreateIndexStream({ client, stats, skipExisting, log }) {
     stream.push(record);
   }
 
-  async function handleIndex(record) {
+  async function handleIndex(record: DocRecord) {
     const { index, settings, mappings, aliases } = record.value;
     const isKibana = index.startsWith('.kibana');
 
@@ -102,7 +125,7 @@ export function createCreateIndexStream({ client, stats, skipExisting, log }) {
             break;
         }
 
-        callback(null);
+        callback();
       } catch (err) {
         callback(err);
       }
diff --git a/src/es_archiver/lib/indices/delete_index.js b/src/es_archiver/lib/indices/delete_index.ts
similarity index 76%
rename from src/es_archiver/lib/indices/delete_index.js
rename to src/es_archiver/lib/indices/delete_index.ts
index 6f60d9533a36b..e3fca587fbc3d 100644
--- a/src/es_archiver/lib/indices/delete_index.js
+++ b/src/es_archiver/lib/indices/delete_index.ts
@@ -18,22 +18,34 @@
  */
 
 import { get } from 'lodash';
+import { Client } from 'elasticsearch';
+import { ToolingLog } from '@kbn/dev-utils';
+import { Stats } from '../stats';
 
 // see https://github.com/elastic/elasticsearch/blob/99f88f15c5febbca2d13b5b5fda27b844153bf1a/server/src/main/java/org/elasticsearch/cluster/SnapshotsInProgress.java#L313-L319
 const PENDING_SNAPSHOT_STATUSES = ['INIT', 'STARTED', 'WAITING'];
 
-export async function deleteIndex(options) {
+export async function deleteIndex(options: {
+  client: Client;
+  stats: Stats;
+  index: string;
+  log: ToolingLog;
+  retryIfSnapshottingCount?: number;
+}): Promise<void> {
   const { client, stats, index, log, retryIfSnapshottingCount = 10 } = options;
 
   const getIndicesToDelete = async () => {
     const aliasInfo = await client.indices.getAlias({ name: index, ignore: [404] });
-    return aliasInfo.status === 404 ? index : Object.keys(aliasInfo);
+    return aliasInfo.status === 404 ? [index] : Object.keys(aliasInfo);
   };
 
   try {
     const indicesToDelete = await getIndicesToDelete();
     await client.indices.delete({ index: indicesToDelete });
-    stats.deletedIndex(indicesToDelete);
+    for (let i = 0; i < indicesToDelete.length; i++) {
+      const indexToDelete = indicesToDelete[i];
+      stats.deletedIndex(indexToDelete);
+    }
   } catch (error) {
     if (retryIfSnapshottingCount > 0 && isDeleteWhileSnapshotInProgressError(error)) {
       stats.waitingForInProgressSnapshot(index);
@@ -56,7 +68,7 @@ export async function deleteIndex(options) {
  * @param  {Error} error
  * @return {Boolean}
  */
-export function isDeleteWhileSnapshotInProgressError(error) {
+export function isDeleteWhileSnapshotInProgressError(error: object) {
   return get(error, 'body.error.reason', '').startsWith(
     'Cannot delete indices that are being snapshotted'
   );
@@ -65,13 +77,9 @@ export function isDeleteWhileSnapshotInProgressError(error) {
 /**
  * Wait for the any snapshot in any repository that is
  * snapshotting this index to complete.
- *
- * @param  {EsClient} client
- * @param  {string} index the name of the index to look for
- * @return {Promise<undefined>}
  */
-export async function waitForSnapshotCompletion(client, index, log) {
-  const isSnapshotPending = async (repository, snapshot) => {
+export async function waitForSnapshotCompletion(client: Client, index: string, log: ToolingLog) {
+  const isSnapshotPending = async (repository: string, snapshot: string) => {
     const {
       snapshots: [status],
     } = await client.snapshot.status({
@@ -83,7 +91,7 @@ export async function waitForSnapshotCompletion(client, index, log) {
     return PENDING_SNAPSHOT_STATUSES.includes(status.state);
   };
 
-  const getInProgressSnapshots = async repository => {
+  const getInProgressSnapshots = async (repository: string) => {
     const { snapshots: inProgressSnapshots } = await client.snapshot.get({
       repository,
       snapshot: '_current',
@@ -91,9 +99,9 @@ export async function waitForSnapshotCompletion(client, index, log) {
     return inProgressSnapshots;
   };
 
-  for (const repository of Object.keys(await client.snapshot.getRepository())) {
+  for (const repository of Object.keys(await client.snapshot.getRepository({} as any))) {
     const allInProgress = await getInProgressSnapshots(repository);
-    const found = allInProgress.find(s => s.indices.includes(index));
+    const found = allInProgress.find((s: any) => s.indices.includes(index));
 
     if (!found) {
       continue;
diff --git a/src/es_archiver/lib/indices/delete_index_stream.js b/src/es_archiver/lib/indices/delete_index_stream.ts
similarity index 86%
rename from src/es_archiver/lib/indices/delete_index_stream.js
rename to src/es_archiver/lib/indices/delete_index_stream.ts
index 31a49ed30a124..b4e1e530e1f84 100644
--- a/src/es_archiver/lib/indices/delete_index_stream.js
+++ b/src/es_archiver/lib/indices/delete_index_stream.ts
@@ -18,11 +18,19 @@
  */
 
 import { Transform } from 'stream';
+import { Client } from 'elasticsearch';
+import { ToolingLog } from '@kbn/dev-utils';
 
+import { Stats } from '../stats';
 import { deleteIndex } from './delete_index';
 import { cleanKibanaIndices } from './kibana_index';
 
-export function createDeleteIndexStream(client, stats, log, kibanaPluginIds) {
+export function createDeleteIndexStream(
+  client: Client,
+  stats: Stats,
+  log: ToolingLog,
+  kibanaPluginIds: string[]
+) {
   return new Transform({
     readableObjectMode: true,
     writableObjectMode: true,
diff --git a/src/es_archiver/lib/indices/generate_index_records_stream.js b/src/es_archiver/lib/indices/generate_index_records_stream.ts
similarity index 89%
rename from src/es_archiver/lib/indices/generate_index_records_stream.js
rename to src/es_archiver/lib/indices/generate_index_records_stream.ts
index 1d1a44aa634c2..b4b98f8ae262c 100644
--- a/src/es_archiver/lib/indices/generate_index_records_stream.js
+++ b/src/es_archiver/lib/indices/generate_index_records_stream.ts
@@ -18,14 +18,16 @@
  */
 
 import { Transform } from 'stream';
+import { Client } from 'elasticsearch';
+import { Stats } from '../stats';
 
-export function createGenerateIndexRecordsStream(client, stats) {
+export function createGenerateIndexRecordsStream(client: Client, stats: Stats) {
   return new Transform({
     writableObjectMode: true,
     readableObjectMode: true,
     async transform(indexOrAlias, enc, callback) {
       try {
-        const resp = await client.indices.get({
+        const resp = (await client.indices.get({
           index: indexOrAlias,
           filterPath: [
             '*.settings',
@@ -36,7 +38,7 @@ export function createGenerateIndexRecordsStream(client, stats) {
             '-*.settings.index.version',
             '-*.settings.index.provided_name',
           ],
-        });
+        })) as Record<string, any>;
 
         for (const [index, { settings, mappings }] of Object.entries(resp)) {
           const {
diff --git a/src/es_archiver/lib/indices/index.js b/src/es_archiver/lib/indices/index.ts
similarity index 100%
rename from src/es_archiver/lib/indices/index.js
rename to src/es_archiver/lib/indices/index.ts
diff --git a/src/es_archiver/lib/indices/kibana_index.js b/src/es_archiver/lib/indices/kibana_index.ts
similarity index 70%
rename from src/es_archiver/lib/indices/kibana_index.js
rename to src/es_archiver/lib/indices/kibana_index.ts
index 744132bdcef69..de67ba7c4e31e 100644
--- a/src/es_archiver/lib/indices/kibana_index.js
+++ b/src/es_archiver/lib/indices/kibana_index.ts
@@ -17,29 +17,34 @@
  * under the License.
  */
 
-import _ from 'lodash';
+import { get } from 'lodash';
 import fs from 'fs';
-import path from 'path';
+import Path from 'path';
 import { promisify } from 'util';
 import { toArray } from 'rxjs/operators';
+import { Client, CreateDocumentParams } from 'elasticsearch';
+import { ToolingLog } from '@kbn/dev-utils';
 
+import { Stats } from '../stats';
 import { deleteIndex } from './delete_index';
-import { collectUiExports } from '../../../legacy/ui/ui_exports';
 import { KibanaMigrator } from '../../../core/server/saved_objects/migrations';
 import { SavedObjectsSchema } from '../../../core/server/saved_objects';
+// @ts-ignore
+import { collectUiExports } from '../../../legacy/ui/ui_exports';
+// @ts-ignore
 import { findPluginSpecs } from '../../../legacy/plugin_discovery';
 
 /**
  * Load the uiExports for a Kibana instance, only load uiExports from xpack if
  * it is enabled in the Kibana server.
  */
-const getUiExports = async kibanaPluginIds => {
+const getUiExports = async (kibanaPluginIds: string[]) => {
   const xpackEnabled = kibanaPluginIds.includes('xpack_main');
 
   const { spec$ } = await findPluginSpecs({
     plugins: {
-      scanDirs: [path.resolve(__dirname, '../../../legacy/core_plugins')],
-      paths: xpackEnabled ? [path.resolve(__dirname, '../../../../x-pack')] : [],
+      scanDirs: [Path.resolve(__dirname, '../../../legacy/core_plugins')],
+      paths: xpackEnabled ? [Path.resolve(__dirname, '../../../../x-pack')] : [],
     },
   });
 
@@ -50,7 +55,15 @@ const getUiExports = async kibanaPluginIds => {
 /**
  * Deletes all indices that start with `.kibana`
  */
-export async function deleteKibanaIndices({ client, stats, log }) {
+export async function deleteKibanaIndices({
+  client,
+  stats,
+  log,
+}: {
+  client: Client;
+  stats: Stats;
+  log: ToolingLog;
+}) {
   const indexNames = await fetchKibanaIndices(client);
   if (!indexNames.length) {
     return;
@@ -76,37 +89,52 @@ export async function deleteKibanaIndices({ client, stats, log }) {
  * builds up an object that implements just enough of the kbnMigrations interface
  * as is required by migrations.
  */
-export async function migrateKibanaIndex({ client, log, kibanaPluginIds }) {
+export async function migrateKibanaIndex({
+  client,
+  log,
+  kibanaPluginIds,
+}: {
+  client: Client;
+  log: ToolingLog;
+  kibanaPluginIds: string[];
+}) {
   const uiExports = await getUiExports(kibanaPluginIds);
   const kibanaVersion = await loadKibanaVersion();
 
-  const config = {
+  const config: Record<string, string> = {
     'xpack.task_manager.index': '.kibana_task_manager',
   };
 
+  const logger = {
+    trace: log.verbose.bind(log),
+    debug: log.debug.bind(log),
+    info: log.info.bind(log),
+    warn: log.warning.bind(log),
+    error: log.error.bind(log),
+    fatal: log.error.bind(log),
+    log: (entry: any) => log.info(entry.message),
+    get: () => logger,
+  };
+
   const migratorOptions = {
-    config: { get: path => config[path] },
+    config: { get: (path: string) => config[path] } as any,
     savedObjectsConfig: {
       scrollDuration: '5m',
       batchSize: 100,
       pollInterval: 100,
+      skip: false,
     },
     kibanaConfig: {
       index: '.kibana',
-    },
-    logger: {
-      trace: log.verbose.bind(log),
-      debug: log.debug.bind(log),
-      info: log.info.bind(log),
-      warn: log.warning.bind(log),
-      error: log.error.bind(log),
-    },
-    version: kibanaVersion,
+    } as any,
+    logger,
+    kibanaVersion,
     savedObjectSchemas: new SavedObjectsSchema(uiExports.savedObjectSchemas),
     savedObjectMappings: uiExports.savedObjectMappings,
     savedObjectMigrations: uiExports.savedObjectMigrations,
     savedObjectValidations: uiExports.savedObjectValidations,
-    callCluster: (path, ...args) => _.get(client, path).call(client, ...args),
+    callCluster: (path: string, ...args: any[]) =>
+      (get(client, path) as Function).call(client, ...args),
   };
 
   return await new KibanaMigrator(migratorOptions).runMigrations();
@@ -114,8 +142,8 @@ export async function migrateKibanaIndex({ client, log, kibanaPluginIds }) {
 
 async function loadKibanaVersion() {
   const readFile = promisify(fs.readFile);
-  const packageJson = await readFile(path.join(__dirname, '../../../../package.json'));
-  return JSON.parse(packageJson).version;
+  const packageJson = await readFile(Path.join(__dirname, '../../../../package.json'));
+  return JSON.parse(packageJson.toString('utf-8')).version;
 }
 
 /**
@@ -123,16 +151,24 @@ async function loadKibanaVersion() {
  * .kibana, .kibana_1, .kibana_323, etc. This finds all indices starting
  * with .kibana, then filters out any that aren't actually Kibana's core
  * index (e.g. we don't want to remove .kibana_task_manager or the like).
- *
- * @param {string} index
  */
-async function fetchKibanaIndices(client) {
+async function fetchKibanaIndices(client: Client) {
   const kibanaIndices = await client.cat.indices({ index: '.kibana*', format: 'json' });
-  const isKibanaIndex = index => /^\.kibana(:?_\d*)?$/.test(index);
-  return kibanaIndices.map(x => x.index).filter(isKibanaIndex);
+  const isKibanaIndex = (index: string) => /^\.kibana(:?_\d*)?$/.test(index);
+  return kibanaIndices.map((x: { index: string }) => x.index).filter(isKibanaIndex);
 }
 
-export async function cleanKibanaIndices({ client, stats, log, kibanaPluginIds }) {
+export async function cleanKibanaIndices({
+  client,
+  stats,
+  log,
+  kibanaPluginIds,
+}: {
+  client: Client;
+  stats: Stats;
+  log: ToolingLog;
+  kibanaPluginIds: string[];
+}) {
   if (!kibanaPluginIds.includes('spaces')) {
     return await deleteKibanaIndices({
       client,
@@ -178,7 +214,7 @@ export async function cleanKibanaIndices({ client, stats, log, kibanaPluginIds }
   stats.deletedIndex('.kibana');
 }
 
-export async function createDefaultSpace({ index, client }) {
+export async function createDefaultSpace({ index, client }: { index: string; client: Client }) {
   await client.create({
     index,
     id: 'space:default',
@@ -193,5 +229,5 @@ export async function createDefaultSpace({ index, client }) {
         _reserved: true,
       },
     },
-  });
+  } as CreateDocumentParams);
 }
diff --git a/src/es_archiver/lib/records/__tests__/filter_records_stream.js b/src/es_archiver/lib/records/__tests__/filter_records_stream.ts
similarity index 97%
rename from src/es_archiver/lib/records/__tests__/filter_records_stream.js
rename to src/es_archiver/lib/records/__tests__/filter_records_stream.ts
index fd35575ca59ba..d5830478decba 100644
--- a/src/es_archiver/lib/records/__tests__/filter_records_stream.js
+++ b/src/es_archiver/lib/records/__tests__/filter_records_stream.ts
@@ -51,7 +51,7 @@ describe('esArchiver: createFilterRecordsStream()', () => {
 
   it('produces record values that have a matching type', async () => {
     const type1 = chance.word({ length: 5 });
-    const output = await createPromiseFromStreams([
+    const output = await createPromiseFromStreams<any[]>([
       createListStream([
         { type: type1, value: {} },
         { type: type1, value: {} },
diff --git a/src/es_archiver/lib/records/filter_records_stream.js b/src/es_archiver/lib/records/filter_records_stream.ts
similarity index 91%
rename from src/es_archiver/lib/records/filter_records_stream.js
rename to src/es_archiver/lib/records/filter_records_stream.ts
index 5a835ffe8e84d..191cbd3b921e3 100644
--- a/src/es_archiver/lib/records/filter_records_stream.js
+++ b/src/es_archiver/lib/records/filter_records_stream.ts
@@ -19,14 +19,14 @@
 
 import { Transform } from 'stream';
 
-export function createFilterRecordsStream(type) {
+export function createFilterRecordsStream(type: string) {
   return new Transform({
     writableObjectMode: true,
     readableObjectMode: true,
 
     transform(record, enc, callback) {
       if (record && record.type === type) {
-        callback(null, record);
+        callback(undefined, record);
       } else {
         callback();
       }
diff --git a/src/es_archiver/lib/records/index.js b/src/es_archiver/lib/records/index.ts
similarity index 100%
rename from src/es_archiver/lib/records/index.js
rename to src/es_archiver/lib/records/index.ts
diff --git a/src/es_archiver/lib/stats.ts b/src/es_archiver/lib/stats.ts
index 5f73304abf9a8..c69b764fc7290 100644
--- a/src/es_archiver/lib/stats.ts
+++ b/src/es_archiver/lib/stats.ts
@@ -37,6 +37,8 @@ export interface IndexStats {
   };
 }
 
+export type Stats = ReturnType<typeof createStats>;
+
 export function createStats(name: string, log: ToolingLog) {
   const info = (msg: string, ...args: any[]) => log.info(`[${name}] ${msg}`, ...args);
   const debug = (msg: string, ...args: any[]) => log.debug(`[${name}] ${msg}`, ...args);
diff --git a/src/legacy/utils/index.d.ts b/src/legacy/utils/index.d.ts
index a57caad1d34bf..c294c79542bbe 100644
--- a/src/legacy/utils/index.d.ts
+++ b/src/legacy/utils/index.d.ts
@@ -18,3 +18,16 @@
  */
 
 export function unset(object: object, rawPath: string): void;
+
+export {
+  concatStreamProviders,
+  createConcatStream,
+  createFilterStream,
+  createIntersperseStream,
+  createListStream,
+  createMapStream,
+  createPromiseFromStreams,
+  createReduceStream,
+  createReplaceStream,
+  createSplitStream,
+} from './streams';
diff --git a/src/legacy/utils/streams/index.d.ts b/src/legacy/utils/streams/index.d.ts
index b8d4c67050b2d..5ef39b292c685 100644
--- a/src/legacy/utils/streams/index.d.ts
+++ b/src/legacy/utils/streams/index.d.ts
@@ -20,17 +20,17 @@
 import { Readable, Transform, Writable, TransformOptions } from 'stream';
 
 export function concatStreamProviders(
-  sourceProviders: Readable[],
+  sourceProviders: Array<() => Readable>,
   options: TransformOptions
 ): Transform;
 export function createIntersperseStream(intersperseChunk: string | Buffer): Transform;
 export function createSplitStream<T>(splitChunk: T): Transform;
-export function createListStream(items: any[]): Readable;
+export function createListStream(items: any | any[]): Readable;
 export function createReduceStream<T>(reducer: (value: any, chunk: T, enc: string) => T): Transform;
 export function createPromiseFromStreams<T>([first, ...rest]: [Readable, ...Writable[]]): Promise<
   T
 >;
-export function createConcatStream(initial: any): Transform;
+export function createConcatStream(initial?: any): Transform;
 export function createMapStream<T>(fn: (value: T, i: number) => void): Transform;
 export function createReplaceStream(toReplace: string, replacement: string | Buffer): Transform;
 export function createFilterStream<T>(fn: (obj: T) => boolean): Transform;