@spinnaker/google 2026.2.2 → 2026.3.0

package/dist/instance/custom/customInstanceBuilder.gce.service.d.ts

@@ -1,2 +1,17 @@
-export const GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCEBUILDER_GCE_SERVICE: "spinnaker.serverGroup.customInstanceBuilder.gce.service";
-export const name: "spinnaker.serverGroup.customInstanceBuilder.gce.service";
+export class GceCustomInstanceBuilderService {
+    vCpuCountForLocationIsValid(instanceFamily: any, vCpuCount: any, location: any, locationToInstanceTypesMap: any): boolean;
+    numberOfVCpusIsValid(instanceFamily: any, vCpuCount: any): boolean;
+    generateValidVCpuListForLocation(location: any, locationToInstanceTypesMap: any): any[];
+    generateValidInstanceFamilyList(): string[];
+    minMemoryForVCpuCount(instanceFamily: any, vCpuCount: any): number;
+    maxMemoryForVCpuCount(instanceFamily: any, vCpuCount: any): number;
+    generateValidMemoryListForVCpuCount(instanceFamily: any, vCpuCount: any): number[];
+    memoryIsValid(instanceFamily: any, totalMemory: any, vCpuCount: any, extendedMemory: any): boolean;
+    generateInstanceTypeString(instanceFamily: any, vCpuCount: any, totalMemory: any, extendedMemory: any): string;
+    parseInstanceTypeString(instanceTypeString: any): {
+        instanceFamily: any;
+        vCpuCount: number;
+        memory: number;
+    };
+    customInstanceChoicesAreValid(instanceFamily: any, vCpuCount: any, totalMemory: any, location: any, locationToInstanceTypesMap: any, extendedMemory: any): boolean;
+}

package/dist/instance/details/GceInstanceDetails.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { IRouterInjectedProps } from '@spinnaker/core';
+interface IGceInstanceDetailsProps extends IRouterInjectedProps {
+    app: any;
+    instance?: any;
+    initialInstance?: any;
+    $stateParams?: any;
+}
+export declare function decorateInstance(instance: any): any;
+export declare function GceInstanceActionsComponent({ app, instance, stateService, }: {
+    app: any;
+    instance: any;
+} & IRouterInjectedProps): JSX.Element;
+export declare function GceInstanceDetailsComponent(props: IGceInstanceDetailsProps): JSX.Element;
+export declare const GceInstanceActions: React.ForwardRefExoticComponent<Omit<{
+    app: any;
+    instance: any;
+} & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export declare const GceInstanceDetails: React.ForwardRefExoticComponent<Omit<IGceInstanceDetailsProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export {};

package/dist/instance/gceInstanceType.service.d.ts

@@ -1,2 +1,3 @@
-export const GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE: "spinnaker.gce.instanceType.service";
-export const name: "spinnaker.gce.instanceType.service";
+export class GceInstanceTypeService {
+    constructor(promiseService: any, logger?: Console);
+}

package/dist/instance/gceMultiInstanceTask.transformer.d.ts

@@ -1,2 +1,3 @@
-export const GOOGLE_INSTANCE_GCEMULTIINSTANCETASK_TRANSFORMER: "spinnaker.google.instance.multiInstance.task.transformer";
-export const name: "spinnaker.google.instance.multiInstance.task.transformer";
+export class GceMultiInstanceTaskTransformer {
+    transform: (instanceGroup: any, job: any) => void;
+}

package/dist/loadBalancer/configure/choice/GceLoadBalancerChoiceModal.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import type { GceLoadBalancerType } from '../common';
+import './GceLoadBalancerChoiceModal.less';
+interface IGceLoadBalancerModal {
+    show: (props: any) => Promise<any>;
+}
+export interface IGceLoadBalancerChoice {
+    description: string;
+    label: string;
+    type: GceLoadBalancerType;
+}
+export declare const GCE_LOAD_BALANCER_CHOICES: IGceLoadBalancerChoice[];
+export interface IGceLoadBalancerChoiceModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    forPipelineConfig?: boolean;
+    isNew?: boolean;
+    loadBalancer?: Record<string, any> | null;
+}
+interface IGceLoadBalancerChoiceModalState {
+    selectedChoice: IGceLoadBalancerChoice | null;
+}
+export declare function getGceLoadBalancerModal(type: GceLoadBalancerType): IGceLoadBalancerModal;
+export declare class GceLoadBalancerChoiceModal extends React.Component<IGceLoadBalancerChoiceModalProps, IGceLoadBalancerChoiceModalState> {
+    static defaultProps: Partial<IGceLoadBalancerChoiceModalProps>;
+    static supportsPipelineConfig: boolean;
+    static show(props: IGceLoadBalancerChoiceModalProps): Promise<any>;
+    state: IGceLoadBalancerChoiceModalState;
+    choiceSelected: (selectedChoice: IGceLoadBalancerChoice) => void;
+    private choose;
+    render(): JSX.Element;
+}
+export {};

package/dist/loadBalancer/configure/common/GceProxyLoadBalancerEditor.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import type { IGceLoadBalancerData, IGceLoadBalancerDataItem } from './gceLoadBalancerData';
+import type { GceLoadBalancerProtocol, IGceLoadBalancerCommand, IGceResourceReference } from './gceLoadBalancerModels';
+export type GceProxyLoadBalancerType = 'INTERNAL' | 'TCP' | 'SSL';
+export interface IGceProxyTypeConfig {
+    backendProtocols: readonly GceLoadBalancerProtocol[];
+    frontendProtocols: readonly GceLoadBalancerProtocol[];
+}
+export declare const GCE_PROXY_TYPE_CONFIG: Record<GceProxyLoadBalancerType, IGceProxyTypeConfig>;
+interface IGceProxyDataItem extends IGceLoadBalancerDataItem {
+    account?: string;
+    credentials?: string;
+    network?: string | IGceResourceReference;
+    region?: string;
+}
+export interface IGceProxyResourceOptions extends IGceLoadBalancerData {
+    accounts: IGceProxyDataItem[];
+    addresses: IGceProxyDataItem[];
+    backendServices: IGceProxyDataItem[];
+    certificates: IGceProxyDataItem[];
+    healthChecks: IGceProxyDataItem[];
+    networks: IGceProxyDataItem[];
+    regions: IGceProxyDataItem[];
+    subnets: IGceProxyDataItem[];
+}
+export interface IGceProxyLoadBalancerEditorProps {
+    command: IGceLoadBalancerCommand;
+    data: IGceLoadBalancerData;
+    disabled?: boolean;
+    onChange: (command: IGceLoadBalancerCommand) => void;
+}
+export declare function applyGceProxyTypeConstraints(command: IGceLoadBalancerCommand): IGceLoadBalancerCommand;
+export declare function getGceProxyResourceOptions(command: IGceLoadBalancerCommand, data: IGceLoadBalancerData): IGceProxyResourceOptions;
+export declare function validateGceProxyLoadBalancerCommand(command: IGceLoadBalancerCommand): string[];
+export declare function GceProxyLoadBalancerEditor({ command, data, disabled, onChange, }: IGceProxyLoadBalancerEditorProps): JSX.Element;
+export {};

package/dist/loadBalancer/configure/common/GceProxyLoadBalancerModal.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { GceProxyLoadBalancerType } from './GceProxyLoadBalancerEditor';
+import type { IGceLoadBalancerDataReaders } from './gceLoadBalancerData';
+import type { GceLoadBalancerEditorMode, IGceLoadBalancerCommand, IGceSerializedLoadBalancerCommand } from './gceLoadBalancerModels';
+type UnknownRecord = Record<string, any>;
+export interface IGceProxyLoadBalancerPayload extends IGceSerializedLoadBalancerCommand {
+    backendService: UnknownRecord;
+    backendServices?: undefined;
+    healthChecks?: undefined;
+    ports?: string[];
+}
+export interface IGceProxyLoadBalancerModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    forPipelineConfig?: boolean;
+    isNew?: boolean;
+    loadBalancer?: UnknownRecord;
+    loadBalancerType?: GceProxyLoadBalancerType | string;
+    readers?: IGceLoadBalancerDataReaders;
+}
+interface IGceProxySubmissionDependencies {
+    application: Application;
+    closeModal?: (command: IGceProxyLoadBalancerPayload) => void;
+    taskMonitor: Pick<TaskMonitor, 'submit'>;
+}
+export declare function normalizeGceProxyLoadBalancerCommand(persisted: UnknownRecord | undefined, mode: GceLoadBalancerEditorMode, loadBalancerType: GceProxyLoadBalancerType, applicationName?: string): IGceLoadBalancerCommand;
+export declare function serializeGceProxyLoadBalancerCommand(command: IGceLoadBalancerCommand): IGceProxyLoadBalancerPayload;
+export declare function submitGceProxyLoadBalancerCommand(command: IGceLoadBalancerCommand, { application, closeModal, taskMonitor }: IGceProxySubmissionDependencies): void;
+declare function GceProxyLoadBalancerModalComponent(props: IGceProxyLoadBalancerModalProps): JSX.Element;
+export declare const GceProxyLoadBalancerModal: typeof GceProxyLoadBalancerModalComponent & {
+    show: (props: IGceProxyLoadBalancerModalProps) => Promise<any>;
+    supportsPipelineConfig: boolean;
+};
+export {};

package/dist/loadBalancer/configure/common/gceLoadBalancerData.d.ts

@@ -0,0 +1,47 @@
+export interface IGceLoadBalancerDataItem {
+    name: string;
+}
+export interface IGceLoadBalancerData {
+    accounts: IGceLoadBalancerDataItem[];
+    addresses: IGceLoadBalancerDataItem[];
+    backendServices: IGceLoadBalancerDataItem[];
+    certificates: IGceLoadBalancerDataItem[];
+    healthChecks: IGceLoadBalancerDataItem[];
+    networks: IGceLoadBalancerDataItem[];
+    regions: IGceLoadBalancerDataItem[];
+    subnets: IGceLoadBalancerDataItem[];
+}
+export interface IGceLoadBalancerDataReaders {
+    accounts: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    addresses: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    backendServices: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    certificates: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    healthChecks: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    networks: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+    regions: (account: string) => PromiseLike<IGceLoadBalancerDataItem[]>;
+    subnets: () => PromiseLike<IGceLoadBalancerDataItem[]>;
+}
+export type GceLoadBalancerDataStatus = 'idle' | 'loading' | 'ready' | 'error';
+export interface IGceLoadBalancerDataState {
+    data: IGceLoadBalancerData;
+    error?: unknown;
+    status: GceLoadBalancerDataStatus;
+}
+type GceLoadBalancerDataListener = (state: IGceLoadBalancerDataState) => void;
+export declare class GceLoadBalancerDataController {
+    private readers;
+    private disposed;
+    private listeners;
+    private requestId;
+    private state;
+    constructor(readers?: IGceLoadBalancerDataReaders);
+    getState(): IGceLoadBalancerDataState;
+    subscribe(listener: GceLoadBalancerDataListener): () => void;
+    load(account: string): Promise<void>;
+    dispose(): void;
+    private isCurrent;
+    private publish;
+}
+export declare function mergeGceResourceOptions<T extends IGceLoadBalancerDataItem>(available: readonly T[], persisted: readonly T[]): T[];
+export declare const gceLoadBalancerDataReaders: IGceLoadBalancerDataReaders;
+export {};

package/dist/loadBalancer/configure/common/gceLoadBalancerModels.d.ts

@@ -0,0 +1,106 @@
+export declare const GCE_LOAD_BALANCER_TYPES: readonly ["NETWORK", "INTERNAL", "TCP", "SSL", "HTTP", "INTERNAL_MANAGED"];
+export type GceLoadBalancerType = typeof GCE_LOAD_BALANCER_TYPES[number];
+export type GceLoadBalancerEditorMode = 'create' | 'edit' | 'pipeline';
+export type GceLoadBalancerProtocol = 'TCP' | 'UDP' | 'HTTP' | 'HTTPS' | 'HTTP2' | 'GRPC' | 'SSL';
+export interface IGceLoadBalancerCapabilities {
+    address: boolean;
+    backendServices: boolean;
+    certificates: boolean;
+    healthChecks: boolean;
+    hostRules: boolean;
+    network: boolean;
+    subnet: boolean;
+}
+export declare const GCE_LOAD_BALANCER_CAPABILITIES: Record<GceLoadBalancerType, IGceLoadBalancerCapabilities>;
+export interface IGceResourceReference {
+    name: string;
+    selfLink?: string;
+    [key: string]: unknown;
+}
+export interface IGceLoadBalancerListener {
+    name: string;
+    protocol: GceLoadBalancerProtocol;
+    portRange: string;
+    address?: IGceResourceReference;
+    certificate?: IGceResourceReference;
+    certificateMap?: string;
+    subnet?: IGceResourceReference;
+}
+export interface IGceLoadBalancerHealthCheck {
+    checkIntervalSec?: number;
+    grpcServiceName?: string;
+    healthCheckType?: GceLoadBalancerProtocol;
+    healthyThreshold?: number;
+    host?: string;
+    name?: string;
+    port?: number;
+    proxyHeader?: string;
+    requestPath?: string;
+    timeoutSec?: number;
+    unhealthyThreshold?: number;
+    useServingPort?: boolean;
+    [key: string]: unknown;
+}
+export interface IGceLoadBalancerBackendService {
+    name: string;
+    healthCheck?: IGceResourceReference;
+    [key: string]: unknown;
+}
+export interface IGceLoadBalancerPathRule {
+    backendService?: IGceResourceReference;
+    paths: string[];
+}
+export interface IGceLoadBalancerPathMatcher {
+    defaultService?: IGceResourceReference;
+    pathRules: IGceLoadBalancerPathRule[];
+}
+export interface IGceLoadBalancerHostRule {
+    hostPatterns: string[];
+    pathMatcher: IGceLoadBalancerPathMatcher;
+}
+export interface IGceLoadBalancerOriginalState {
+    backendServices: IGceLoadBalancerBackendService[];
+    healthChecks: IGceLoadBalancerHealthCheck[];
+    listeners: IGceLoadBalancerListener[];
+}
+interface IGceLoadBalancerCommandBase {
+    mode: GceLoadBalancerEditorMode;
+    name: string;
+    credentials: string;
+    region: string;
+    loadBalancerType: GceLoadBalancerType;
+    listeners: IGceLoadBalancerListener[];
+    healthChecks: IGceLoadBalancerHealthCheck[];
+    backendServices: IGceLoadBalancerBackendService[];
+    hostRules: IGceLoadBalancerHostRule[];
+    defaultService?: IGceResourceReference;
+    network?: IGceResourceReference;
+    original?: IGceLoadBalancerOriginalState;
+    subnet?: IGceResourceReference;
+}
+export interface IGceCreateLoadBalancerCommand extends IGceLoadBalancerCommandBase {
+    mode: 'create';
+}
+export interface IGceEditLoadBalancerCommand extends IGceLoadBalancerCommandBase {
+    mode: 'edit';
+}
+export interface IGcePipelineLoadBalancerCommand extends IGceLoadBalancerCommandBase {
+    mode: 'pipeline';
+}
+export type IGceLoadBalancerCommand = IGceCreateLoadBalancerCommand | IGceEditLoadBalancerCommand | IGcePipelineLoadBalancerCommand;
+export interface IGceSerializedLoadBalancerCommand {
+    [key: string]: unknown;
+    cloudProvider: 'gce';
+    credentials: string;
+    loadBalancerName: string;
+    loadBalancerType: GceLoadBalancerType;
+    name: string;
+    provider: 'gce';
+    region: string;
+    type: 'upsertLoadBalancer';
+}
+type UnknownRecord = Record<string, unknown>;
+export declare function normalizeGceLoadBalancerCommand(persisted: UnknownRecord, mode: GceLoadBalancerEditorMode): IGceLoadBalancerCommand;
+export declare function serializeGceLoadBalancerCommand(command: IGceLoadBalancerCommand): IGceSerializedLoadBalancerCommand;
+export declare function normalizeGceHealthCheck(value: unknown): IGceLoadBalancerHealthCheck;
+export {};

package/dist/loadBalancer/configure/common/gceLoadBalancerSubmission.d.ts

@@ -0,0 +1,10 @@
+import type { Application, ITask, ITaskCommand } from '@spinnaker/core';
+import type { IGceLoadBalancerCommand, IGceSerializedLoadBalancerCommand } from './gceLoadBalancerModels';
+export interface IGceLoadBalancerSubmissionDependencies {
+    application: Application;
+    executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+}
+export type GceLoadBalancerOperationList = IGceSerializedLoadBalancerCommand[];
+export type GceLoadBalancerSubmissionResult = IGceSerializedLoadBalancerCommand | GceLoadBalancerOperationList | Promise<ITask>;
+export declare function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceLoadBalancerOperationList;
+export declare function submitGceLoadBalancerCommand(command: IGceLoadBalancerCommand, { application, executeTask }: IGceLoadBalancerSubmissionDependencies): GceLoadBalancerSubmissionResult;

package/dist/loadBalancer/configure/common/index.d.ts

@@ -0,0 +1,4 @@
+export * from './gceLoadBalancerData';
+export * from './gceLoadBalancerModels';
+export * from './gceLoadBalancerSubmission';
+export * from './useGceLoadBalancerData';

package/dist/loadBalancer/configure/common/useGceLoadBalancerData.d.ts

@@ -0,0 +1,5 @@
+import type { IGceLoadBalancerDataReaders, IGceLoadBalancerDataState } from './gceLoadBalancerData';
+export interface IUseGceLoadBalancerDataResult extends IGceLoadBalancerDataState {
+    refresh: () => void;
+}
+export declare function useGceLoadBalancerData(account: string, readers?: IGceLoadBalancerDataReaders): IUseGceLoadBalancerDataResult;

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerEditor.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { IGceLoadBalancerCommand, IGceLoadBalancerData, IGceLoadBalancerDataItem } from '../common';
+import './httpLoadBalancerWizard.component.less';
+export interface IGceHttpLoadBalancerEditorProps {
+    command: IGceLoadBalancerCommand;
+    data: IGceLoadBalancerData;
+    onChange: (command: IGceLoadBalancerCommand) => void;
+}
+interface IGceHttpLoadBalancerDataItem extends IGceLoadBalancerDataItem {
+    account?: string;
+    id?: string;
+    network?: string;
+    region?: string;
+}
+export declare function FormRow({ children, label }: {
+    children: React.ReactNode;
+    label: string;
+}): JSX.Element;
+export interface IGceHttpLoadBalancerOptions extends IGceLoadBalancerData {
+    accounts: IGceHttpLoadBalancerDataItem[];
+    addresses: IGceHttpLoadBalancerDataItem[];
+    backendServices: IGceHttpLoadBalancerDataItem[];
+    certificates: IGceHttpLoadBalancerDataItem[];
+    healthChecks: IGceHttpLoadBalancerDataItem[];
+    networks: IGceHttpLoadBalancerDataItem[];
+    regions: IGceHttpLoadBalancerDataItem[];
+    subnets: IGceHttpLoadBalancerDataItem[];
+}
+export declare function buildGceHttpLoadBalancerOptions(command: IGceLoadBalancerCommand, data: IGceLoadBalancerData): IGceHttpLoadBalancerOptions;
+export declare function constrainGceHttpLoadBalancerCommand(command: IGceLoadBalancerCommand): IGceLoadBalancerCommand;
+export declare function validateGceHttpLoadBalancerCommand(command: IGceLoadBalancerCommand): string[];
+export declare function GceHttpLoadBalancerEditor({ command, data, onChange }: IGceHttpLoadBalancerEditorProps): JSX.Element;
+export {};

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerListenerEditor.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { GceLoadBalancerType, IGceLoadBalancerDataItem, IGceLoadBalancerListener } from '../common';
+export interface IGceHttpLoadBalancerListenerEditorProps {
+    addresses: IGceLoadBalancerDataItem[];
+    certificates: IGceLoadBalancerDataItem[];
+    listener: IGceLoadBalancerListener;
+    loadBalancerType: GceLoadBalancerType;
+    onChange: (listener: IGceLoadBalancerListener) => void;
+    onRemove: () => void;
+    subnets: IGceLoadBalancerDataItem[];
+}
+export declare function GceHttpLoadBalancerListenerEditor({ addresses, certificates, listener, loadBalancerType, onChange, onRemove, subnets, }: IGceHttpLoadBalancerListenerEditorProps): JSX.Element;

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerModal.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import type { Application, IModalComponentProps, ITask, ITaskCommand } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { GceLoadBalancerEditorMode, GceLoadBalancerType, IGceLoadBalancerCommand, IGceLoadBalancerData, IGceLoadBalancerDataReaders, IGceLoadBalancerDataState } from '../common';
+export interface IGceHttpLoadBalancerModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    credentials?: string;
+    data?: IGceLoadBalancerData;
+    dataReaders?: IGceLoadBalancerDataReaders;
+    executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+    forPipelineConfig?: boolean;
+    isNew?: boolean;
+    loadBalancer?: Record<string, unknown>;
+    loadBalancerType?: Extract<GceLoadBalancerType, 'HTTP' | 'INTERNAL_MANAGED'>;
+    mode?: GceLoadBalancerEditorMode;
+}
+interface IGceHttpLoadBalancerModalState extends IGceLoadBalancerDataState {
+    command: IGceLoadBalancerCommand;
+    taskMonitor: TaskMonitor;
+}
+export declare function initializeGceHttpLoadBalancerCommand(source: Record<string, unknown>, mode: GceLoadBalancerEditorMode, application: Application, defaults?: Partial<Record<'credentials' | 'loadBalancerType', unknown>>): IGceLoadBalancerCommand;
+export declare class GceHttpLoadBalancerModal extends React.Component<IGceHttpLoadBalancerModalProps, IGceHttpLoadBalancerModalState> {
+    static supportsPipelineConfig: boolean;
+    static show(props: IGceHttpLoadBalancerModalProps): Promise<unknown>;
+    private dataController?;
+    private unsubscribe?;
+    constructor(props: IGceHttpLoadBalancerModalProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private application;
+    private mode;
+    private updateCommand;
+    private submit;
+    render(): JSX.Element;
+}
+export {};

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerResourceEditors.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import type { GceLoadBalancerType, IGceLoadBalancerBackendService, IGceLoadBalancerDataItem, IGceLoadBalancerHealthCheck } from '../common';
+export interface IGceHttpLoadBalancerHealthCheckEditorProps {
+    healthCheck: IGceLoadBalancerHealthCheck;
+    healthChecks: IGceLoadBalancerDataItem[];
+    onChange: (healthCheck: IGceLoadBalancerHealthCheck) => void;
+    onRemove: () => void;
+}
+export declare function GceHttpLoadBalancerHealthCheckEditor({ healthCheck, healthChecks, onChange, onRemove, }: IGceHttpLoadBalancerHealthCheckEditorProps): JSX.Element;
+export interface IGceHttpLoadBalancerBackendServiceEditorProps {
+    backendService: IGceLoadBalancerBackendService;
+    backendServices: IGceLoadBalancerDataItem[];
+    healthChecks: IGceLoadBalancerDataItem[];
+    loadBalancerType: GceLoadBalancerType;
+    onChange: (backendService: IGceLoadBalancerBackendService) => void;
+    onRemove: () => void;
+}
+export declare function GceHttpLoadBalancerBackendServiceEditor({ backendService, backendServices, healthChecks, loadBalancerType, onChange, onRemove, }: IGceHttpLoadBalancerBackendServiceEditorProps): JSX.Element;

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerRoutingEditor.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import type { IGceLoadBalancerDataItem, IGceLoadBalancerHostRule, IGceLoadBalancerPathRule } from '../common';
+export interface IGceHttpLoadBalancerPathRuleEditorProps {
+    backendServices: IGceLoadBalancerDataItem[];
+    onChange: (pathRule: IGceLoadBalancerPathRule) => void;
+    onRemove: () => void;
+    pathRule: IGceLoadBalancerPathRule;
+}
+export declare function GceHttpLoadBalancerPathRuleEditor({ backendServices, onChange, onRemove, pathRule, }: IGceHttpLoadBalancerPathRuleEditorProps): JSX.Element;
+export interface IGceHttpLoadBalancerHostRuleEditorProps {
+    backendServices: IGceLoadBalancerDataItem[];
+    hostRule: IGceLoadBalancerHostRule;
+    onChange: (hostRule: IGceLoadBalancerHostRule) => void;
+    onRemove: () => void;
+}
+export declare function GceHttpLoadBalancerHostRuleEditor({ backendServices, hostRule, onChange, onRemove, }: IGceHttpLoadBalancerHostRuleEditorProps): JSX.Element;

package/dist/loadBalancer/configure/network/GceNetworkLoadBalancerEditor.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import type { IGceLoadBalancerCommand, IGceLoadBalancerData, IGceLoadBalancerDataItem, IGceLoadBalancerHealthCheck, IGceResourceReference } from '../common';
+export type GceNetworkSessionAffinity = 'NONE' | 'CLIENT_IP' | 'CLIENT_IP_PROTO';
+export type IGceNetworkLoadBalancerCommand = IGceLoadBalancerCommand & {
+    loadBalancerType: 'NETWORK';
+    sessionAffinity: GceNetworkSessionAffinity;
+    targetPool?: IGceResourceReference;
+};
+interface IGceNetworkDataItem extends IGceLoadBalancerDataItem {
+    account?: string;
+    credentials?: string;
+    network?: string | IGceResourceReference;
+    region?: string;
+}
+export interface IGceNetworkLoadBalancerOptions {
+    accounts: IGceNetworkDataItem[];
+    addresses: IGceNetworkDataItem[];
+    networks: IGceNetworkDataItem[];
+    regions: IGceNetworkDataItem[];
+}
+export interface IGceNetworkLoadBalancerEditorProps {
+    command: IGceNetworkLoadBalancerCommand;
+    data: IGceLoadBalancerData;
+    onChange: (command: IGceNetworkLoadBalancerCommand) => void;
+}
+export declare function createGceNetworkHealthCheck(): IGceLoadBalancerHealthCheck;
+export declare function buildGceNetworkLoadBalancerOptions(command: IGceNetworkLoadBalancerCommand, data: IGceLoadBalancerData): IGceNetworkLoadBalancerOptions;
+export declare function validateGceNetworkLoadBalancerCommand(command: IGceNetworkLoadBalancerCommand): string[];
+export declare function GceNetworkLoadBalancerEditor({ command, data, onChange, }: IGceNetworkLoadBalancerEditorProps): JSX.Element;
+export {};

package/dist/loadBalancer/configure/network/GceNetworkLoadBalancerModal.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+import type { Application, IModalComponentProps, ITask, ITaskCommand } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { GceNetworkSessionAffinity, IGceNetworkLoadBalancerCommand } from './GceNetworkLoadBalancerEditor';
+import type { GceLoadBalancerEditorMode, IGceLoadBalancerData, IGceLoadBalancerDataReaders, IGceLoadBalancerDataState, IGceSerializedLoadBalancerCommand } from '../common';
+type UnknownRecord = Record<string, any>;
+interface IGceNetworkHealthCheckPayload {
+    checkIntervalSec?: number;
+    healthyThreshold?: number;
+    port?: number;
+    requestPath?: string;
+    timeoutSec?: number;
+    unhealthyThreshold?: number;
+}
+export interface IGceNetworkLoadBalancerPayload extends IGceSerializedLoadBalancerCommand {
+    healthCheck: IGceNetworkHealthCheckPayload | null;
+    sessionAffinity: GceNetworkSessionAffinity;
+}
+export interface IGceNetworkLoadBalancerModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    credentials?: string;
+    data?: IGceLoadBalancerData;
+    dataReaders?: IGceLoadBalancerDataReaders;
+    executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+    forPipelineConfig?: boolean;
+    isNew?: boolean;
+    loadBalancer?: UnknownRecord;
+    mode?: GceLoadBalancerEditorMode;
+}
+interface IGceNetworkLoadBalancerModalState extends IGceLoadBalancerDataState {
+    command: IGceNetworkLoadBalancerCommand;
+    taskMonitor: TaskMonitor;
+}
+interface IGceNetworkSubmissionDependencies {
+    application: Application;
+    executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+}
+export declare function normalizeGceNetworkLoadBalancerCommand(persisted: UnknownRecord | null | undefined, mode: GceLoadBalancerEditorMode, applicationName?: string, defaults?: Partial<Record<'credentials' | 'region', unknown>>): IGceNetworkLoadBalancerCommand;
+export declare function serializeGceNetworkLoadBalancerCommand(command: IGceNetworkLoadBalancerCommand): IGceNetworkLoadBalancerPayload;
+export declare function submitGceNetworkLoadBalancerCommand(command: IGceNetworkLoadBalancerCommand, { application, executeTask }: IGceNetworkSubmissionDependencies): IGceNetworkLoadBalancerPayload | Promise<ITask>;
+declare class GceNetworkLoadBalancerModalComponent extends React.Component<IGceNetworkLoadBalancerModalProps, IGceNetworkLoadBalancerModalState> {
+    private dataController?;
+    private unsubscribe?;
+    constructor(props: IGceNetworkLoadBalancerModalProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+    private application;
+    private mode;
+    private updateCommand;
+    private submit;
+}
+export declare const GceNetworkLoadBalancerModal: typeof GceNetworkLoadBalancerModalComponent & {
+    show: (props: IGceNetworkLoadBalancerModalProps) => Promise<any>;
+    supportsPipelineConfig: boolean;
+};
+export {};

package/dist/loadBalancer/details/gceLoadBalancerDetails.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import { AccountService } from '@spinnaker/core';
+interface IUseDetailsProps {
+    app: any;
+    autoClose: () => void;
+    loadBalancerParams: any;
+}
+interface ILoadGceLoadBalancerDetailsProps extends IUseDetailsProps {
+    accountService?: typeof AccountService;
+    loadBalancers?: any[];
+    loadBalancerReader: any;
+}
+export declare function loadGceLoadBalancerDetails({ accountService, app, autoClose, loadBalancers, loadBalancerParams, loadBalancerReader, }: ILoadGceLoadBalancerDetailsProps): Promise<any | undefined>;
+export declare function useGceLoadBalancerDetails({ app, autoClose, loadBalancerParams }: IUseDetailsProps): any;
+export declare function GceLoadBalancerActions({ app, loadBalancer }: {
+    app: any;
+    loadBalancer: any;
+}): JSX.Element;
+export declare function GceLoadBalancerInformationSection({ loadBalancer }: {
+    app: any;
+    loadBalancer: any;
+}): JSX.Element;
+export declare function GceLoadBalancerListenersSection({ loadBalancer }: {
+    app: any;
+    loadBalancer: any;
+}): JSX.Element;
+export declare function GceLoadBalancerBackendServicesSection({ loadBalancer }: {
+    app: any;
+    loadBalancer: any;
+}): JSX.Element;
+export declare function GceLoadBalancerLogsSection({ loadBalancer }: {
+    app: any;
+    loadBalancer: any;
+}): JSX.Element;
+export declare const gceLoadBalancerDetailsSections: (typeof GceLoadBalancerInformationSection)[];
+export {};

package/dist/loadBalancer/httpLoadBalancerUtils.service.d.ts

@@ -4,4 +4,3 @@ export declare class GceHttpLoadBalancerUtils {
     isHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer;
     normalizeLoadBalancerNamesForAccount(loadBalancerNames: string[], account: string, loadBalancers: IGceLoadBalancer[]): string[];
 }
-export declare const GCE_HTTP_LOAD_BALANCER_UTILS = "spinnaker.gce.httpLoadBalancerUtils.service";

package/dist/loadBalancer/loadBalancer.setTransformer.d.ts

@@ -1,11 +1,7 @@
 import type { IGceLoadBalancer } from '../domain/loadBalancer';
-import type { GceHttpLoadBalancerUtils } from './httpLoadBalancerUtils.service';
 export declare class GceLoadBalancerSetTransformer {
-    private gceHttpLoadBalancerUtils;
+    private readonly gceHttpLoadBalancerUtils;
     private static normalizeHttpLoadBalancerGroup;
     private static parsePortRange;
-    static $inject: string[];
-    constructor(gceHttpLoadBalancerUtils: GceHttpLoadBalancerUtils);
     normalizeLoadBalancerSet: (loadBalancers: IGceLoadBalancer[]) => IGceLoadBalancer[];
 }
-export declare const LOAD_BALANCER_SET_TRANSFORMER = "spinnaker.gce.loadBalancer.setTransformer.service";

package/dist/loadBalancer/loadBalancer.transformer.d.ts

@@ -1,2 +1,3 @@
-export const GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER: "spinnaker.gce.loadBalancer.transformer";
-export const name: "spinnaker.gce.loadBalancer.transformer";
+export class GceLoadBalancerTransformer {
+    constructor(promiseService: any);
+}

package/dist/pipeline/stages/bake/gceBakeStage.d.ts

@@ -1,2 +1,2 @@
-export const GOOGLE_PIPELINE_STAGES_BAKE_GCEBAKESTAGE: "spinnaker.gce.pipeline.stage..bakeStage";
-export const name: "spinnaker.gce.pipeline.stage..bakeStage";
+export function interpolatedBakeDetailUrl(stage: any): any;
+export function registerGceBakeStage(): void;

package/dist/pipeline/stages/cloneServerGroup/gceCloneServerGroupStage.d.ts

@@ -1,2 +1 @@
-export const GOOGLE_PIPELINE_STAGES_CLONESERVERGROUP_GCECLONESERVERGROUPSTAGE: "spinnaker.gce.pipeline.stage..cloneServerGroupStage";
-export const name: "spinnaker.gce.pipeline.stage..cloneServerGroupStage";
+export function registerGceCloneServerGroupStage(): void;

package/dist/pipeline/stages/destroyAsg/gceDestroyAsgStage.d.ts

@@ -1,2 +1 @@
-export const GOOGLE_PIPELINE_STAGES_DESTROYASG_GCEDESTROYASGSTAGE: "spinnaker.gce.pipeline.stage..destroyAsgStage";
-export const name: "spinnaker.gce.pipeline.stage..destroyAsgStage";
+export function registerGceDestroyAsgStage(): void;