@spinnaker/google 2026.2.2 → 2026.3.0

package/dist/serverGroup/details/GceInstanceFlexibilityPolicyDetails.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { IGceInstanceFlexibilityPolicy } from '../../domain/serverGroup';
+export interface IGceInstanceFlexibilityPolicyDetailsProps {
+    instanceFlexibilityPolicy?: IGceInstanceFlexibilityPolicy;
+}
+export declare function GceInstanceFlexibilityPolicyDetails({ instanceFlexibilityPolicy, }: IGceInstanceFlexibilityPolicyDetailsProps): JSX.Element;

package/dist/serverGroup/details/autoHealingPolicy/GceAutoHealingPolicyDetails.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { Application, IManagedResource } from '@spinnaker/core';
+import type { IGcePolicyServerGroup } from '../../../autoscalingPolicy';
+import type { IGceAutoHealingPolicy } from '../../../domain';
+export interface IGceAutoHealingPolicyDetailsProps {
+    application: Application;
+    mutationsEnabled: boolean;
+    serverGroup: IGcePolicyServerGroup & IManagedResource;
+    policy?: IGceAutoHealingPolicy;
+}
+export declare function GceAutoHealingPolicyDetails({ application, mutationsEnabled, serverGroup, policy, }: IGceAutoHealingPolicyDetailsProps): JSX.Element | null;

package/dist/serverGroup/details/autoHealingPolicy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GceAutoHealingPolicyDetails';
+export * from './modal/GceUpsertAutoHealingPolicyModal';

package/dist/serverGroup/details/autoHealingPolicy/modal/GceUpsertAutoHealingPolicyModal.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IGcePolicyServerGroup } from '../../../../autoscalingPolicy';
+import type { IGceAutoHealingPolicy } from '../../../../domain';
+export interface IGceUpsertAutoHealingPolicyModalProps extends IModalComponentProps {
+    application: Application;
+    serverGroup: IGcePolicyServerGroup;
+    policy?: IGceAutoHealingPolicy;
+}
+interface IGceUpsertAutoHealingPolicyModalState {
+    policy: IGceAutoHealingPolicy;
+    taskMonitor: TaskMonitor;
+}
+export declare class GceUpsertAutoHealingPolicyModal extends React.Component<IGceUpsertAutoHealingPolicyModalProps, IGceUpsertAutoHealingPolicyModalState> {
+    static show(props: IGceUpsertAutoHealingPolicyModalProps): Promise<void>;
+    constructor(props: IGceUpsertAutoHealingPolicyModalProps);
+    private submit;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/details/autoscalingPolicy/GceAutoscalingPolicyDetails.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { Application, IManagedResource } from '@spinnaker/core';
+import type { IGceAutoscalingPolicy, IGcePolicyServerGroup } from '../../../autoscalingPolicy';
+export interface IGceAutoscalingPolicyDetailsProps {
+    application: Application;
+    mutationsEnabled: boolean;
+    serverGroup: IGcePolicyServerGroup & IManagedResource & {
+        autoscalingMessages?: string[];
+    };
+    policy?: IGceAutoscalingPolicy;
+}
+export declare function GceAutoscalingPolicyDetails({ application, mutationsEnabled, serverGroup, policy, }: IGceAutoscalingPolicyDetailsProps): JSX.Element | null;

package/dist/serverGroup/details/autoscalingPolicy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GceAutoscalingPolicyDetails';
+export * from './modal/GceUpsertAutoscalingPolicyModal';

package/dist/serverGroup/details/autoscalingPolicy/modal/GceUpsertAutoscalingPolicyModal.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IGceAutoscalingPolicy, IGcePolicyServerGroup } from '../../../../autoscalingPolicy';
+export interface IGceUpsertAutoscalingPolicyModalProps extends IModalComponentProps {
+    application: Application;
+    serverGroup: IGcePolicyServerGroup & {
+        capacity?: {
+            min?: number;
+            max?: number;
+        };
+    };
+    policy?: IGceAutoscalingPolicy;
+}
+interface IGceUpsertAutoscalingPolicyModalState {
+    policy: IGceAutoscalingPolicy;
+    taskMonitor: TaskMonitor;
+}
+export declare class GceUpsertAutoscalingPolicyModal extends React.Component<IGceUpsertAutoscalingPolicyModalProps, IGceUpsertAutoscalingPolicyModalState> {
+    static show(props: IGceUpsertAutoscalingPolicyModalProps): Promise<void>;
+    constructor(props: IGceUpsertAutoscalingPolicyModalProps);
+    private submit;
+    render(): JSX.Element;
+    private isValid;
+}
+export {};

package/dist/serverGroup/details/gceServerGroupDetails.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import { Observable } from 'rxjs';
+import { useDeckRuntimeServices } from '@spinnaker/core';
+import type { Application } from '@spinnaker/core';
+import type { IGceServerGroup } from '../../domain';
+export declare function gceServerGroupDetailsGetter(props: any, autoClose: () => void): Observable<any>;
+export declare function cloneGceServerGroup(app: any, serverGroup: any, commandBuilder: any, runtimeServices: ReturnType<typeof useDeckRuntimeServices>): Promise<void>;
+export declare function GceServerGroupActions({ app, serverGroup }: {
+    app: any;
+    serverGroup: any;
+}): JSX.Element;
+export declare function GceServerGroupInformationSection({ serverGroup }: {
+    app: any;
+    serverGroup: any;
+}): JSX.Element;
+export declare function GceServerGroupCapacitySection({ serverGroup }: {
+    app: any;
+    serverGroup: any;
+}): JSX.Element;
+export declare function GceServerGroupLaunchConfigSection({ serverGroup }: {
+    app: any;
+    serverGroup: any;
+}): JSX.Element;
+export declare function GceAutoscalingPolicySection({ app, serverGroup, }: {
+    app: Application;
+    serverGroup: IGceServerGroup;
+}): JSX.Element;
+export declare function GceAutoHealingPolicySection({ app, serverGroup, }: {
+    app: Application;
+    serverGroup: IGceServerGroup;
+}): JSX.Element;
+export declare const gceServerGroupDetailsSections: (typeof GceServerGroupInformationSection)[];

package/dist/serverGroup/details/resize/GceResizeServerGroupModal.d.ts

@@ -0,0 +1,60 @@
+import React from 'react';
+import type { Application, IModalComponentProps, IServerGroup, IServerGroupJob, ITask } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IGceAutoscalingPolicy } from '../../../autoscalingPolicy/IGceAutoscalingPolicy';
+export interface IGceResizeValues {
+    interestingHealthProviderNames?: string[];
+    newMaxNumReplicas?: number;
+    newMinNumReplicas?: number;
+    newSize?: number;
+    reason?: string;
+}
+export type GceResizeErrors = Partial<Record<keyof IGceResizeValues, string>>;
+export interface IGceFixedResizeJob extends IServerGroupJob {
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+    targetSize: number;
+}
+export interface IGceAutoscalerResizeRequest {
+    params: {
+        interestingHealthProviderNames?: string[];
+        reason?: string;
+    };
+    policy: IGceAutoscalingPolicy & {
+        maxNumReplicas: number;
+        minNumReplicas: number;
+    };
+}
+export interface IGceAutoscalingPolicyWriter {
+    upsertAutoscalingPolicy(application: Application, serverGroup: IServerGroup, policy: IGceAutoscalerResizeRequest['policy'], params: IGceAutoscalerResizeRequest['params']): Promise<ITask>;
+}
+export interface IGceResizeServerGroupWriter {
+    resizeServerGroup(serverGroup: IServerGroup, application: Application, command: IGceFixedResizeJob): Promise<ITask>;
+}
+export interface IGceResizeServerGroupModalProps extends IModalComponentProps {
+    application: Application;
+    autoscalingPolicyWriter: IGceAutoscalingPolicyWriter;
+    serverGroup: IServerGroup;
+    serverGroupWriter: IGceResizeServerGroupWriter;
+}
+interface IGceResizeServerGroupModalState {
+    taskMonitor: TaskMonitor;
+    values: IGceResizeValues;
+    verified: boolean;
+}
+export declare function buildGceAutoscalerResizeRequest(values: IGceResizeValues & {
+    newMaxNumReplicas: number;
+    newMinNumReplicas: number;
+}): IGceAutoscalerResizeRequest;
+export declare function buildGceFixedResizeJob(serverGroup: IServerGroup, values: IGceResizeValues & {
+    newSize: number;
+}): IGceFixedResizeJob;
+export declare function validateGceResizeValues(serverGroup: IServerGroup, values: IGceResizeValues): GceResizeErrors;
+export declare class GceResizeServerGroupModal extends React.Component<IGceResizeServerGroupModalProps, IGceResizeServerGroupModalState> {
+    static show(props: IGceResizeServerGroupModalProps): Promise<void>;
+    constructor(props: IGceResizeServerGroupModalProps);
+    private isValid;
+    private submit;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/details/rollback/GceRollbackServerGroupModal.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { Application, IModalComponentProps, IServerGroup, IServerGroupJob, ITask } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+export interface IGceRollbackValues {
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+    restoreServerGroupName?: string;
+}
+export interface IGceRollbackJob extends IServerGroupJob {
+    interestingHealthProviderNames?: string[];
+    platformHealthOnlyShowOverride?: boolean;
+    reason?: string;
+    rollbackContext: {
+        restoreServerGroupName?: string;
+        rollbackServerGroupName: string;
+    };
+    rollbackType: 'EXPLICIT';
+}
+export interface IGceRollbackServerGroupWriter {
+    rollbackServerGroup(serverGroup: IServerGroup, application: Application, command: IGceRollbackJob): Promise<ITask>;
+}
+export interface IGceRollbackServerGroupModalProps extends IModalComponentProps {
+    application: Application;
+    serverGroup: IServerGroup;
+    serverGroups: IServerGroup[];
+    serverGroupWriter: IGceRollbackServerGroupWriter;
+}
+interface IGceRollbackServerGroupModalState {
+    taskMonitor: TaskMonitor;
+    values: IGceRollbackValues;
+    verified: boolean;
+}
+export declare function buildGceRollbackJob(application: Application, serverGroup: IServerGroup, values: IGceRollbackValues): IGceRollbackJob;
+export declare function getGceRollbackCandidates(application: Application, serverGroup: IServerGroup, candidates: IServerGroup[]): IServerGroup[];
+export declare class GceRollbackServerGroupModal extends React.Component<IGceRollbackServerGroupModalProps, IGceRollbackServerGroupModalState> {
+    static defaultProps: Partial<IGceRollbackServerGroupModalProps>;
+    static show(props: IGceRollbackServerGroupModalProps): Promise<IGceRollbackJob>;
+    constructor(props: IGceRollbackServerGroupModalProps);
+    private close;
+    private isValid;
+    private submit;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/details/stateful/StatefulMIGService.d.ts

@@ -1,7 +1,7 @@
 import type { IGceServerGroup } from '../../../domain';
 export declare class StatefulMIGService {
-    static markDiskStateful(applicationName: string, deviceName: string, serverGroup: IGceServerGroup): PromiseLike<import("@spinnaker/core").ITask>;
-    static statefullyUpdateBootDisk(applicationName: string, bootImage: string, serverGroup: IGceServerGroup): PromiseLike<import("@spinnaker/core").ITask>;
+    static markDiskStateful(applicationName: string, deviceName: string, serverGroup: IGceServerGroup): Promise<import("@spinnaker/core").ITask>;
+    static statefullyUpdateBootDisk(applicationName: string, bootImage: string, serverGroup: IGceServerGroup): Promise<import("@spinnaker/core").ITask>;
     static isDiskStateful(deviceName: string, serverGroup: IGceServerGroup): boolean;
     static statefulMigsEnabled(): boolean;
 }

package/dist/serverGroup/serverGroup.transformer.d.ts

@@ -1,2 +1,2 @@
-export const GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER: "spinnaker.gce.serverGroup.transformer";
-export const name: "spinnaker.gce.serverGroup.transformer";
+export class GceServerGroupTransformer {
+}

package/dist/subnet/subnet.renderer.d.ts

@@ -1,2 +1,4 @@
-export const GOOGLE_SUBNET_SUBNET_RENDERER: "spinnaker.gce.subnet.renderer";
-export const name: "spinnaker.gce.subnet.renderer";
+export class GceSubnetRenderer {
+    gceNetworks: any;
+    render(serverGroup: any): any;
+}

package/dist/validation/ApplicationNameValidator.d.ts

@@ -0,0 +1,6 @@
+import type { IApplicationNameValidator, IValidationResult } from '@spinnaker/core';
+export declare class GoogleApplicationNameValidator implements IApplicationNameValidator {
+    private validateSpecialCharacters;
+    private validateLength;
+    validate(name?: string): IValidationResult;
+}

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
   "license": "Apache-2.0",
-  "version": "2026.2.2",
+  "version": "2026.3.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -22,28 +22,19 @@
   },
   "dependencies": {
     "@spinnaker/core": "^0.29.1",
-    "@uirouter/angularjs": "1.0.26",
-    "angular": "1.6.10",
-    "angular-ui-bootstrap": "2.5.0",
     "lodash": "4.18.1",
-    "ngimport": "0.6.1",
     "react": "16.14.0",
     "react-select": "1.2.1",
-    "react2angular": "3.2.1",
-    "rxjs": "6.6.7",
-    "ui-select": "0.19.8"
+    "rxjs": "6.6.7"
   },
   "devDependencies": {
     "@spinnaker/eslint-plugin": "^3.0.2",
     "@spinnaker/scripts": "^0.4.0",
-    "@types/angular": "1.6.26",
-    "@types/angular-mocks": "1.5.10",
-    "@types/angular-ui-bootstrap": "0.13.41",
     "@types/lodash": "4.14.64",
     "@types/react": "16.14.10",
     "@types/react-select": "1.3.4",
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "db086c61529c9421e8c0c2d4a2b8eca88c675ac8"
+  "gitHead": "0f7d75f5d4b42c1675e2ecc69a53f8eb73090eb9"
 }

package/src/autoHealingPolicy/GceAutoHealingPolicyEditor.spec.tsx

@@ -0,0 +1,133 @@
+import React from 'react';
+import { shallow } from 'enzyme';
+
+import { IGceHealthCheckKind } from '../domain';
+import { GceAutoHealingPolicyEditor } from './GceAutoHealingPolicyEditor';
+
+describe('GceAutoHealingPolicyEditor', () => {
+  async function flush(): Promise<void> {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  it('loads only health checks from the selected account', async () => {
+    const reader = {
+      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(
+        Promise.resolve([
+          {
+            account: 'my-account',
+            name: 'web',
+            kind: IGceHealthCheckKind.healthCheck,
+            selfLink: 'https://compute/healthChecks/web',
+          },
+          {
+            account: 'other-account',
+            name: 'other',
+            kind: IGceHealthCheckKind.httpHealthCheck,
+            selfLink: 'https://compute/httpHealthChecks/other',
+          },
+        ]),
+      ),
+    };
+    const wrapper = shallow(
+      <GceAutoHealingPolicyEditor account="my-account" policy={{}} onChange={() => undefined} reader={reader as any} />,
+    );
+
+    await flush();
+    wrapper.update();
+
+    expect(wrapper.find('[data-testid="health-check"] option').length).toBe(2);
+    expect(wrapper.find('[data-testid="health-check"]').text()).toContain('web');
+    expect(wrapper.find('[data-testid="health-check"]').text()).not.toContain('other');
+  });
+
+  it('writes the selected health check name and kind from its URL', () => {
+    const onChange = jasmine.createSpy('onChange');
+    const wrapper = shallow(
+      <GceAutoHealingPolicyEditor account="my-account" policy={{ initialDelaySec: 0 }} onChange={onChange} />,
+      { disableLifecycleMethods: true },
+    );
+
+    wrapper.find('[data-testid="health-check"]').simulate('change', {
+      target: { value: 'https://compute/httpHealthChecks/web' },
+    });
+
+    expect(onChange).toHaveBeenCalledWith({
+      initialDelaySec: 0,
+      healthCheckUrl: 'https://compute/httpHealthChecks/web',
+      healthCheck: 'web',
+      healthCheckKind: IGceHealthCheckKind.httpHealthCheck,
+    });
+  });
+
+  it('normalizes an existing healthCheck URL into its URL, name, and kind fields', async () => {
+    const onChange = jasmine.createSpy('onChange');
+    const reader = {
+      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(Promise.resolve([])),
+    };
+    shallow(
+      <GceAutoHealingPolicyEditor
+        account="my-account"
+        policy={{ healthCheck: 'https://compute/httpHealthChecks/web', initialDelaySec: 0 }}
+        onChange={onChange}
+        reader={reader as any}
+      />,
+    );
+
+    await flush();
+
+    expect(onChange).toHaveBeenCalledWith({
+      healthCheckUrl: 'https://compute/httpHealthChecks/web',
+      healthCheck: 'web',
+      healthCheckKind: IGceHealthCheckKind.httpHealthCheck,
+      initialDelaySec: 0,
+    });
+  });
+
+  it('resolves an existing healthCheck name to the matching URL and kind', async () => {
+    const onChange = jasmine.createSpy('onChange');
+    const reader = {
+      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(
+        Promise.resolve([
+          {
+            account: 'my-account',
+            name: 'web',
+            kind: IGceHealthCheckKind.healthCheck,
+            selfLink: 'https://compute/healthChecks/web',
+          },
+        ]),
+      ),
+    };
+    shallow(
+      <GceAutoHealingPolicyEditor
+        account="my-account"
+        policy={{ healthCheck: 'web', initialDelaySec: 0 }}
+        onChange={onChange}
+        reader={reader as any}
+      />,
+    );
+
+    await flush();
+
+    expect(onChange).toHaveBeenCalledWith({
+      healthCheckUrl: 'https://compute/healthChecks/web',
+      healthCheck: 'web',
+      healthCheckKind: IGceHealthCheckKind.healthCheck,
+      initialDelaySec: 0,
+    });
+  });
+
+  it('preserves zero for initial delay without rendering legacy max unavailable controls', () => {
+    const onChange = jasmine.createSpy('onChange');
+    const legacyPolicy = { initialDelaySec: 0, maxUnavailable: { percent: 0 } };
+    const wrapper = shallow(
+      <GceAutoHealingPolicyEditor account="my-account" policy={legacyPolicy as any} onChange={onChange} />,
+      { disableLifecycleMethods: true },
+    );
+
+    expect(wrapper.find('[data-testid="initial-delay"]').prop('value')).toBe(0);
+    expect(wrapper.find('[data-testid="max-unavailable"]').exists()).toBe(false);
+    expect(wrapper.find('[data-testid="max-unavailable-unit"]').exists()).toBe(false);
+    expect(wrapper.text()).not.toContain('Max unavailable');
+  });
+});

package/src/autoHealingPolicy/GceAutoHealingPolicyEditor.tsx

@@ -0,0 +1,143 @@
+import React from 'react';
+
+import type { IGceAutoHealingPolicy } from '../domain';
+import { GceHealthCheckReader } from '../healthCheck/healthCheck.read.service';
+import type { IGceHealthCheckOption } from '../healthCheck/healthCheckUtils';
+import { getHealthCheckOptions, parseHealthCheckUrl } from '../healthCheck/healthCheckUtils';
+
+export interface IGceAutoHealingPolicyEditorProps {
+  account: string;
+  policy: IGceAutoHealingPolicy;
+  onChange: (policy: IGceAutoHealingPolicy) => void;
+  reader?: GceHealthCheckReader;
+}
+
+interface IGceAutoHealingPolicyEditorState {
+  healthChecks: IGceHealthCheckOption[];
+  loading: boolean;
+}
+
+function numberValue(value: string): number | undefined {
+  return value === '' ? undefined : Number(value);
+}
+
+export class GceAutoHealingPolicyEditor extends React.Component<
+  IGceAutoHealingPolicyEditorProps,
+  IGceAutoHealingPolicyEditorState
+> {
+  public state: IGceAutoHealingPolicyEditorState = { healthChecks: [], loading: true };
+
+  public componentDidMount(): void {
+    this.loadHealthChecks();
+  }
+
+  public loadHealthChecks = (): void => {
+    this.setState({ loading: true });
+    (this.props.reader || new GceHealthCheckReader()).listHealthChecks().then((healthChecks) => {
+      const options = getHealthCheckOptions(
+        healthChecks.filter((healthCheck) => healthCheck.account === this.props.account),
+      );
+      this.setState({
+        healthChecks: options,
+        loading: false,
+      });
+      this.normalizeHealthCheck(options);
+    });
+  };
+
+  private update = (changes: Partial<IGceAutoHealingPolicy>): void => {
+    this.props.onChange({ ...this.props.policy, ...changes });
+  };
+
+  private getHealthCheckUrl = (healthChecks = this.state.healthChecks): string => {
+    const { healthCheck, healthCheckKind, healthCheckUrl } = this.props.policy;
+    if (healthCheckUrl) {
+      return healthCheckUrl;
+    }
+    if (healthCheck?.includes('/')) {
+      return healthCheck;
+    }
+    const matches = healthChecks.filter(
+      (option) => option.name === healthCheck && (!healthCheckKind || option.kind === healthCheckKind),
+    );
+    return matches.length === 1 ? matches[0].selfLink : '';
+  };
+
+  private normalizeHealthCheck(healthChecks: IGceHealthCheckOption[]): void {
+    const healthCheckUrl = this.getHealthCheckUrl(healthChecks);
+    if (!healthCheckUrl) {
+      return;
+    }
+    const { healthCheckName, healthCheckKind } = parseHealthCheckUrl(healthCheckUrl);
+    if (
+      this.props.policy.healthCheckUrl !== healthCheckUrl ||
+      this.props.policy.healthCheck !== healthCheckName ||
+      this.props.policy.healthCheckKind !== healthCheckKind
+    ) {
+      this.update({ healthCheckUrl, healthCheck: healthCheckName, healthCheckKind });
+    }
+  }
+
+  public render(): JSX.Element {
+    const { policy } = this.props;
+
+    return (
+      <div className="form-horizontal gce-auto-healing-policy-editor">
+        <div className="form-group">
+          <label className="col-md-4 control-label">Health check</label>
+          <div className="col-md-6">
+            <select
+              className="form-control input-sm"
+              data-testid="health-check"
+              disabled={this.state.loading}
+              value={this.getHealthCheckUrl()}
+              onChange={(event) => {
+                const healthCheckUrl = event.target.value;
+                if (!healthCheckUrl) {
+                  this.update({ healthCheckUrl: undefined, healthCheck: undefined, healthCheckKind: undefined });
+                  return;
+                }
+                const { healthCheckName, healthCheckKind } = parseHealthCheckUrl(healthCheckUrl);
+                this.update({ healthCheckUrl, healthCheck: healthCheckName, healthCheckKind });
+              }}
+            >
+              <option value="">Select...</option>
+              {this.state.healthChecks.map((healthCheck) => (
+                <option key={healthCheck.selfLink} value={healthCheck.selfLink}>
+                  {healthCheck.displayName}
+                </option>
+              ))}
+            </select>
+          </div>
+        </div>
+        <div className="form-group">
+          <label className="col-md-4 control-label">Initial delay</label>
+          <div className="col-md-6 input-group">
+            <input
+              className="form-control input-sm"
+              data-testid="initial-delay"
+              max={2147483647}
+              min={0}
+              type="number"
+              value={policy.initialDelaySec ?? ''}
+              onChange={(event) => this.update({ initialDelaySec: numberValue(event.target.value) })}
+            />
+            <span className="input-group-addon">seconds</span>
+          </div>
+        </div>
+        <div className="form-group">
+          <div className="col-md-offset-4 col-md-6">
+            <button
+              className="btn btn-link"
+              disabled={this.state.loading}
+              type="button"
+              onClick={this.loadHealthChecks}
+            >
+              Refresh health checks
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+}

package/src/autoHealingPolicy/index.ts

@@ -0,0 +1 @@
+export * from './GceAutoHealingPolicyEditor';