@spinnaker/azure 2026.2.2 → 2026.3.0

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

@@ -1,2 +1,6 @@
-export const AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE: "spinnaker.azure.instanceType.service";
-export const name: "spinnaker.azure.instanceType.service";
+export class AzureInstanceTypeService {
+    constructor(promiseService: any);
+    getCategories: () => any;
+    getAvailableTypesForRegions: (locationToInstanceTypesMap: any, selectedLocations: any) => any;
+    getAllTypesByRegion: () => any;
+}

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

@@ -0,0 +1,67 @@
+import React from 'react';
+import type { Application, IInstanceDetailsProps, IRouterInjectedProps } from '@spinnaker/core';
+interface IAzureInstanceParams {
+    account?: string;
+    instanceId: string;
+    provider?: string;
+    region?: string;
+}
+interface IAzureInstanceDetailsProps extends Partial<IInstanceDetailsProps> {
+    app: Application;
+    initialInstance?: IAzureLoadedInstance;
+    instance?: IAzureInstanceParams;
+    $stateParams?: IInstanceDetailsProps['$stateParams'] & Partial<IAzureInstanceParams>;
+}
+interface IAzureLoadInstanceDetailsProps {
+    app: Application;
+    instance: IAzureInstanceParams;
+}
+export interface IAzureLoadedInstance {
+    [key: string]: any;
+    account?: string;
+    baseIpAddress?: string;
+    health?: any[];
+    healthMetrics?: any[];
+    instanceId?: string;
+    instanceIdNotFound?: string;
+    loadBalancers?: string[];
+    region?: string;
+    serverGroup?: string;
+    vpcId?: string;
+}
+export declare function loadAzureInstanceDetails({ app, instance, }: IAzureLoadInstanceDetailsProps): Promise<IAzureLoadedInstance>;
+export declare class AzureInstanceDetailsComponent extends React.Component<IAzureInstanceDetailsProps & IRouterInjectedProps, {
+    instance?: IAzureLoadedInstance;
+    loading: boolean;
+}> {
+    state: {
+        instance: IAzureLoadedInstance;
+        loading: boolean;
+    };
+    private activeRequestId;
+    private isUnmounted;
+    private unsubscribeFromRefresh;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: IAzureInstanceDetailsProps): void;
+    componentWillUnmount(): void;
+    private getInstanceParams;
+    private retrieveInstance;
+    render(): JSX.Element;
+}
+export declare function AzureInstanceActionsComponent({ app, instance, stateService, }: {
+    app: Application;
+    instance: IAzureLoadedInstance;
+} & IRouterInjectedProps): JSX.Element;
+export declare const AzureInstanceActions: React.ForwardRefExoticComponent<Omit<{
+    app: Application;
+    instance: IAzureLoadedInstance;
+} & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export declare const AzureInstanceDetails: React.ForwardRefExoticComponent<Omit<IAzureInstanceDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export declare function AzureInstanceInformationSection({ instance }: {
+    instance: IAzureLoadedInstance;
+}): JSX.Element;
+export {};

package/dist/loadBalancer/configure/AzureLoadBalancerChoiceModal.d.ts

@@ -1,16 +1,21 @@
 import React from 'react';
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { ILoadBalancerModalProps, ILoadBalancerUpsertCommand } from '@spinnaker/core';
 import type { IAzureLoadBalancer } from '../../utility';
 export interface IAzureLoadBalancerChoiceModalState {
     choices: IAzureLoadBalancer[];
     selectedChoice: IAzureLoadBalancer;
 }
-export declare class AzureLoadBalancerChoiceModal extends React.Component<ILoadBalancerModalProps, IAzureLoadBalancerChoiceModalState> {
-    static defaultProps: Partial<ILoadBalancerModalProps>;
-    static show(props: ILoadBalancerModalProps): Promise<void>;
-    constructor(props: ILoadBalancerModalProps);
+interface IAzureLoadBalancerChoiceModalProps extends Omit<ILoadBalancerModalProps, 'closeModal'> {
+    closeModal?(loadBalancerCommand: ILoadBalancerUpsertCommand | Promise<ILoadBalancerUpsertCommand>): void;
+}
+export declare class AzureLoadBalancerChoiceModal extends React.Component<IAzureLoadBalancerChoiceModalProps, IAzureLoadBalancerChoiceModalState> {
+    static defaultProps: Partial<IAzureLoadBalancerChoiceModalProps>;
+    static supportsPipelineConfig: boolean;
+    static show(props: ILoadBalancerModalProps): Promise<ILoadBalancerUpsertCommand>;
+    constructor(props: IAzureLoadBalancerChoiceModalProps);
     choiceSelected(choice: IAzureLoadBalancer): void;
     private choose;
     close: (reason?: any) => void;
     render(): JSX.Element;
 }
+export {};

package/dist/loadBalancer/configure/AzureLoadBalancerModal.d.ts

@@ -0,0 +1,102 @@
+import React from 'react';
+import type { Application, IModalComponentProps, IRouterInjectedProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAzureLoadBalancer } from '../../utility';
+interface IAzureLoadBalancerModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    forPipelineConfig?: boolean;
+    isNew?: boolean;
+    loadBalancer?: any;
+    loadBalancerType?: IAzureLoadBalancer | string;
+}
+interface IAzureVnet {
+    account: string;
+    name: string;
+    region: string;
+    resourceGroup?: string;
+    subnets?: IAzureSubnet[];
+}
+interface IAzureSubnet {
+    devices?: Array<{
+        type: string;
+    }>;
+    name: string;
+}
+interface IAzureLoadBalancerModalState {
+    accounts: any[];
+    accountsLoaded: boolean;
+    existingLoadBalancerNames: string[];
+    loadBalancer: any;
+    regions: any[];
+    selectedSubnets: IAzureSubnet[];
+    selectedVnets: IAzureVnet[];
+    taskMonitor: TaskMonitor;
+}
+interface IValidationOptions {
+    existingLoadBalancerNames?: string[];
+    isNew?: boolean;
+}
+export declare const validSkus: string[];
+export declare function getAzureLoadBalancerTypeChoice(loadBalancer?: any, loadBalancerType?: IAzureLoadBalancer | string): IAzureLoadBalancer;
+export declare function formatInputValue(value: any): any;
+export declare function getAzureVnetSelectValue(vnet: IAzureVnet): string;
+export declare function getAzureVnetSelectLabel(vnet: IAzureVnet): string;
+export declare function findAzureVnetBySelectValue(vnets: IAzureVnet[], value: string): IAzureVnet | null;
+export declare function liftAzureLoadBalancerSessionPersistence(loadBalancer: any, loadBalancerType: string, sourceLoadBalancer?: any): any;
+export declare function isAzureLoadBalancerType(loadBalancerType: string): boolean;
+export declare function shouldRenderCreateFields(isNew: boolean): boolean;
+export declare function shouldRenderNetworkFields(isNew: boolean, loadBalancerType: string): boolean;
+export declare function shouldRenderSkuField(isNew: boolean, loadBalancerType: string): boolean;
+export declare function listenerProtocolOptions(loadBalancerType: string): string[];
+export declare function probeProtocolOptions(loadBalancerType: string): string[];
+export declare function parseOptionalNumber(value: any): number;
+export declare function applyAzureLoadBalancerTypeDefaults(loadBalancer: any, loadBalancerType: string): any;
+export declare function validateAzureLoadBalancerForSubmit(loadBalancer: any, loadBalancerType: string, options?: IValidationOptions): string[];
+export declare function normalizeAzureLoadBalancerForSubmit(loadBalancer: any, loadBalancerType: string): any;
+export declare class AzureLoadBalancerModalComponent extends React.Component<IAzureLoadBalancerModalProps & IRouterInjectedProps, IAzureLoadBalancerModalState> {
+    static defaultProps: Partial<IAzureLoadBalancerModalProps>;
+    static show(props: IAzureLoadBalancerModalProps): Promise<any>;
+    private mounted;
+    private applicationRefreshUnsubscribe?;
+    private transformer;
+    constructor(props: IAzureLoadBalancerModalProps & IRouterInjectedProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private getApplication;
+    private getLoadBalancerType;
+    private initializeLoadBalancer;
+    private initializeCreateMode;
+    private onTaskComplete;
+    private onApplicationRefresh;
+    private getName;
+    private updateName;
+    private accountUpdated;
+    private regionUpdated;
+    private updateLoadBalancerNames;
+    private vnetUpdated;
+    private subnetUpdated;
+    private selectedVnetChanged;
+    private selectedSubnetChanged;
+    private updateLoadBalancer;
+    private updateField;
+    private updateNamePart;
+    private updateProbe;
+    private updateRule;
+    private updateFirstRule;
+    private addListener;
+    private removeListener;
+    private submit;
+    private renderInput;
+    private renderSelect;
+    private renderSkuSelect;
+    private renderProbeInput;
+    private renderFirstRuleInput;
+    render(): JSX.Element;
+}
+export declare const AzureLoadBalancerModal: React.ForwardRefExoticComponent<Omit<IAzureLoadBalancerModalProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof AzureLoadBalancerModalComponent.show;
+};
+export {};

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

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { Application, ILoadBalancer, ILoadBalancerActionsProps, ILoadBalancerDetailsSectionProps, IUseDetailsHookProps, LoadBalancerReader as LoadBalancerReaderType, SecurityGroupReader, UseDetailsResult } from '@spinnaker/core';
+interface ILoadAzureLoadBalancerDetailsProps {
+    app: Application;
+    autoClose: () => void;
+    loadBalancers?: ILoadBalancer[];
+    loadBalancerParams: IAzureLoadBalancerStateParams;
+    loadBalancerReader: LoadBalancerReaderType;
+    securityGroupReader: SecurityGroupReader;
+}
+interface IAzureLoadBalancerStateParams {
+    accountId: string;
+    name: string;
+    provider: string;
+    region: string;
+}
+export declare function loadAzureLoadBalancerDetails({ app, autoClose, loadBalancers, loadBalancerParams, loadBalancerReader: reader, securityGroupReader, }: ILoadAzureLoadBalancerDetailsProps): Promise<ILoadBalancer | undefined>;
+export declare function useAzureLoadBalancerDetails({ app, loadBalancerParams, autoClose, }: IUseDetailsHookProps): UseDetailsResult<ILoadBalancer>;
+export declare function AzureLoadBalancerActions({ app, loadBalancer }: ILoadBalancerActionsProps): JSX.Element;
+export declare function AzureLoadBalancerDetailsSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AzureLoadBalancerListenersSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AzureLoadBalancerHealthChecksSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AzureLoadBalancerStatusSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AzureLoadBalancerFirewallsSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare const azureLoadBalancerDetailsSections: (typeof AzureLoadBalancerDetailsSection)[];
+export {};

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

@@ -1,2 +1,45 @@
-export const AZURE_LOADBALANCER_LOADBALANCER_TRANSFORMER: "spinnaker.azure.loadBalancer.transformer";
-export const name: "spinnaker.azure.loadBalancer.transformer";
+export class AzureLoadBalancerTransformer {
+    constructor(promiseService: any);
+    promiseService: any;
+    normalizeLoadBalancer(loadBalancer: any): any;
+    convertLoadBalancerForEditing(loadBalancer: any): {
+        region: any;
+        credentials: any;
+        name: any;
+        stack: any;
+        detail: any;
+        vnet: any;
+        subnet: any;
+        probes: any[];
+        loadBalancingRules: any[];
+    };
+    constructNewLoadBalancerTemplate(application: any): {
+        stack: string;
+        detail: string;
+        credentials: any;
+        region: any;
+        cloudProvider: string;
+        vnet: any;
+        subnet: any;
+        probes: {
+            probeName: string;
+            probeProtocol: string;
+            probePort: string;
+            probePath: string;
+            probeInterval: number;
+            unhealthyThreshold: number;
+            timeout: number;
+        }[];
+        securityGroups: any[];
+        loadBalancingRules: {
+            ruleName: string;
+            protocol: string;
+            externalPort: number;
+            backendPort: number;
+            probeName: string;
+            persistence: string;
+            idleTimeout: number;
+        }[];
+        sku: string;
+    };
+}

package/dist/pipeline/stages/AzureAccountRegionClusterSelector.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+interface IAzureAccountRegionClusterSelectorProps {
+    application: any;
+    stage: any;
+    updateStageField: (changes: any) => void;
+    onAccountUpdate?: (account: string) => void;
+}
+interface IAzureAccountRegionClusterSelectorState {
+    accounts: any[];
+    freeFormClusterField: boolean;
+    regions: string[];
+}
+export declare class AzureAccountRegionClusterSelector extends React.Component<IAzureAccountRegionClusterSelectorProps, IAzureAccountRegionClusterSelectorState> {
+    private mounted;
+    state: IAzureAccountRegionClusterSelectorState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private serverGroups;
+    private accountOptions;
+    private regionOptions;
+    private clusterOptions;
+    private selectedClusterIsCustom;
+    private monikerForCluster;
+    private updateStageField;
+    private updateAccount;
+    private updateRegion;
+    private updateCluster;
+    private updateFreeFormCluster;
+    private toggleFreeFormClusterField;
+    render(): JSX.Element;
+}
+export {};

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

@@ -1,2 +1,46 @@
-export const AZURE_PIPELINE_STAGES_BAKE_AZUREBAKESTAGE: "spinnaker.azure.pipeline.stage.bakeStage";
-export const name: "spinnaker.azure.pipeline.stage.bakeStage";
+import React from 'react';
+import type { IExecutionDetailsSectionProps } from '@spinnaker/core';
+interface IAzureBakeStageState {
+    accounts: string[];
+    baseLabelOptions: string[];
+    baseOsOptions: any[];
+    extendedAttributeKey: string;
+    extendedAttributeValue: string;
+    loading: boolean;
+    loadError: boolean;
+    managedImageOptions: Array<{
+        id: string;
+        name: string;
+        osType: string;
+    }>;
+    regions: string[];
+    roscoMode: boolean;
+    showAdvancedOptions: boolean;
+    sourceImageMode: 'default' | 'managed' | 'custom';
+}
+export declare class AzureBakeStageConfig extends React.Component<any, IAzureBakeStageState> {
+    private azureImageReader;
+    private mounted;
+    state: IAzureBakeStageState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private initialize;
+    private applyDefaults;
+    private replaceStage;
+    private updateStage;
+    private updateExtendedAttribute;
+    private removeExtendedAttribute;
+    private addExtendedAttribute;
+    private roscoMode;
+    private showAdvanced;
+    private loadManagedImages;
+    private loadAccountRegions;
+    private setSourceImageMode;
+    private onAccountChange;
+    private onManagedImageChange;
+    private renderSourceImageFields;
+    render(): JSX.Element;
+}
+export declare function AzureBakeExecutionDetails({ current, execution, name, stage }: IExecutionDetailsSectionProps): JSX.Element;
+export declare function registerAzureBakeStage(): void;
+export {};

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

@@ -1,2 +1,14 @@
-export const AZURE_PIPELINE_STAGES_DESTROYASG_AZUREDESTROYASGSTAGE: "spinnaker.azure.pipeline.stage.destroyAsgStage";
-export const name: "spinnaker.azure.pipeline.stage.destroyAsgStage";
+import React from 'react';
+export declare function AzureDestroyAsgExecutionLabel({ stage }: any): JSX.Element;
+export declare class AzureDestroyAsgStageConfig extends React.Component<any> {
+    private mounted;
+    componentDidMount(): void;
+    componentDidUpdate(previousProps: any): void;
+    componentWillUnmount(): void;
+    private updateStageField;
+    private applyDefaults;
+    private loadRegionForAccount;
+    private accountUpdated;
+    render(): JSX.Element;
+}
+export declare function registerAzureDestroyAsgStage(): void;

package/dist/pipeline/stages/disableAsg/azureDisableAsgStage.d.ts

@@ -1,2 +1,4 @@
-export const AZURE_PIPELINE_STAGES_DISABLEASG_AZUREDISABLEASGSTAGE: "spinnaker.azure.pipeline.stage.disableAsgStage";
-export const name: "spinnaker.azure.pipeline.stage.disableAsgStage";
+/// <reference types="react" />
+export declare function AzureDisableAsgExecutionLabel({ stage }: any): JSX.Element;
+export declare function AzureDisableAsgStageConfig({ application, pipeline, stage, updateStageField }: any): JSX.Element;
+export declare function registerAzureDisableAsgStage(): void;

package/dist/pipeline/stages/enableAsg/azureEnableAsgStage.d.ts

@@ -1,2 +1,4 @@
-export const AZURE_PIPELINE_STAGES_ENABLEASG_AZUREENABLEASGSTAGE: "spinnaker.azure.pipeline.stage.enableAsgStage";
-export const name: "spinnaker.azure.pipeline.stage.enableAsgStage";
+/// <reference types="react" />
+export declare function AzureEnableAsgExecutionLabel({ stage }: any): JSX.Element;
+export declare function AzureEnableAsgStageConfig({ application, pipeline, stage, updateStageField }: any): JSX.Element;
+export declare function registerAzureEnableAsgStage(): void;

package/dist/securityGroup/configure/AzureSecurityGroupModal.d.ts

@@ -0,0 +1,70 @@
+import React from 'react';
+import type { Application, IModalComponentProps, IRouterInjectedProps, ISecurityGroup } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+export type AzureSecurityGroupModalMode = 'create' | 'edit' | 'clone';
+interface IAzureSecurityGroupModalProps extends IModalComponentProps {
+    app?: Application;
+    application?: Application;
+    credentials?: string;
+    mode: AzureSecurityGroupModalMode;
+    region?: string;
+    securityGroup?: any;
+}
+interface IAzureSecurityGroupModalState {
+    accounts: any[];
+    regions: any[];
+    securityGroup: any;
+    selectedSubnets: IAzureSubnet[];
+    selectedVnets: IAzureVnet[];
+    taskMonitor: TaskMonitor;
+}
+interface IAzureVnet {
+    account: string;
+    name: string;
+    region: string;
+    resourceGroup?: string;
+    subnets?: IAzureSubnet[];
+}
+interface IAzureSubnet {
+    name: string;
+}
+export declare function isAzureSecurityGroupValid(securityGroup: any, mode?: AzureSecurityGroupModalMode, application?: Application): boolean;
+export declare function addSecurityRule(rules: any[]): any[];
+export declare function removeSecurityRule(rules: any[], index: number): any[];
+export declare function moveSecurityRule(rules: any[], fromIndex: number, toIndex: number): any[];
+export declare function normalizeAzureSecurityGroupForSubmit(securityGroup: ISecurityGroup & Record<string, any>): any;
+export declare function getAzureVnetSelectValue(vnet: IAzureVnet): string;
+export declare function initializeAzureSecurityGroupForModal(props: IAzureSecurityGroupModalProps, applicationName: string): any;
+export declare class AzureSecurityGroupModalComponent extends React.Component<IAzureSecurityGroupModalProps & IRouterInjectedProps, IAzureSecurityGroupModalState> {
+    static defaultProps: Partial<IAzureSecurityGroupModalProps>;
+    static show(props: IAzureSecurityGroupModalProps): Promise<any>;
+    private mounted;
+    private applicationRefreshUnsubscribe?;
+    constructor(props: IAzureSecurityGroupModalProps & IRouterInjectedProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private getApplication;
+    onTaskComplete: () => void;
+    private clearApplicationRefreshSubscription;
+    private updateSecurityGroup;
+    private updateField;
+    accountUpdated: (clearNetworkSelections?: boolean) => void;
+    vnetUpdated: (clearNetworkSelections?: boolean) => void;
+    private selectedVnetChanged;
+    private selectedSubnetChanged;
+    private updateRule;
+    private addRule;
+    private removeRule;
+    private moveRule;
+    submit(): void;
+    private renderInput;
+    private renderSelect;
+    private renderNamePreview;
+    render(): JSX.Element;
+}
+export declare const AzureSecurityGroupModal: React.ForwardRefExoticComponent<Omit<IAzureSecurityGroupModalProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof AzureSecurityGroupModalComponent.show;
+};
+export {};

package/dist/securityGroup/details/AzureSecurityGroupDetails.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import type { Application, IOverridableProps, IRouterInjectedProps, ISecurityGroupDetail, SecurityGroupReader } from '@spinnaker/core';
+import { DeckRuntimeContext } from '@spinnaker/core';
+interface IAzureResolvedSecurityGroup {
+    accountId?: string;
+    name: string;
+    provider?: string;
+    region: string;
+    vpcId?: string;
+}
+interface IAzureSecurityGroupDetailsProps extends IOverridableProps {
+    app: Application;
+    autoClose?: () => void;
+    resolvedSecurityGroup: IAzureResolvedSecurityGroup;
+    securityGroupReader?: SecurityGroupReader;
+}
+interface IAzureSecurityGroupDetailsState {
+    loading: boolean;
+    securityGroup?: ISecurityGroupDetail & Record<string, any>;
+}
+interface IAzureSecurityGroupSectionProps {
+    securityGroup: ISecurityGroupDetail & Record<string, any>;
+}
+export declare class AzureSecurityGroupDetailsComponent extends React.Component<IAzureSecurityGroupDetailsProps & IRouterInjectedProps, IAzureSecurityGroupDetailsState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    state: IAzureSecurityGroupDetailsState;
+    private isUnmounted;
+    private loadRequestId;
+    private unsubscribeFromRefresh;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: IAzureSecurityGroupDetailsProps): void;
+    private getCoordinatesKey;
+    private getSecurityGroupReader;
+    private loadSecurityGroup;
+    private autoClose;
+    private closeDetails;
+    render(): JSX.Element;
+}
+export declare const AzureSecurityGroupDetails: React.ForwardRefExoticComponent<Omit<IAzureSecurityGroupDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export declare function AzureSecurityGroupActions({ app, resolvedSecurityGroup, securityGroup, }: {
+    app: Application;
+    resolvedSecurityGroup?: IAzureResolvedSecurityGroup;
+    securityGroup: any;
+}): JSX.Element;
+export declare function AzureSecurityGroupInformationSection({ securityGroup }: IAzureSecurityGroupSectionProps): JSX.Element;
+export declare function AzureSecurityGroupRulesSection({ securityGroup }: IAzureSecurityGroupSectionProps): JSX.Element;
+export {};

package/dist/securityGroup/securityGroup.reader.d.ts

@@ -1,2 +1,3 @@
-export const AZURE_SECURITYGROUP_SECURITYGROUP_READER: "spinnaker.azure.securityGroup.reader";
-export const name: "spinnaker.azure.securityGroup.reader";
+export class AzureSecurityGroupReader {
+    resolveIndexedSecurityGroup(indexedSecurityGroups: any, container: any, securityGroupId: any): any;
+}

package/dist/securityGroup/securityGroup.transformer.d.ts

@@ -1,2 +1,3 @@
-export const AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER: "spinnaker.azure.securityGroup.transformer";
-export const name: "spinnaker.azure.securityGroup.transformer";
+export class AzureSecurityGroupTransformer {
+    normalizeSecurityGroup(): void;
+}

package/dist/securityGroup/securityGroup.write.service.d.ts

@@ -1,2 +1,9 @@
-export const AZURE_SECURITYGROUP_SECURITYGROUP_WRITE_SERVICE: "spinnaker.azure.securityGroup.write.service";
-export const name: "spinnaker.azure.securityGroup.write.service";
+import type { Application, ISecurityGroup, ITask } from '@spinnaker/core';
+type AzureSecurityGroupCommand = Record<string, any>;
+export declare function buildUpsertCommand(securityGroup: ISecurityGroup & AzureSecurityGroupCommand, params?: AzureSecurityGroupCommand): AzureSecurityGroupCommand;
+export declare function buildDeleteCommand(securityGroup: ISecurityGroup & AzureSecurityGroupCommand, application: Application, params?: AzureSecurityGroupCommand): AzureSecurityGroupCommand;
+export declare const AzureSecurityGroupWriter: {
+    upsertSecurityGroup(securityGroup: ISecurityGroup & AzureSecurityGroupCommand, application: Application, descriptor: string, params?: AzureSecurityGroupCommand): Promise<ITask>;
+    deleteSecurityGroup(securityGroup: ISecurityGroup & AzureSecurityGroupCommand, application: Application, params?: AzureSecurityGroupCommand): Promise<ITask>;
+};
+export {};

package/dist/serverGroup/configure/serverGroupCommandBuilder.service.d.ts

@@ -1,2 +1,88 @@
-export const AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE: "spinnaker.azure.serverGroupCommandBuilder.service";
-export const name: "spinnaker.azure.serverGroupCommandBuilder.service";
+export class AzureServerGroupCommandBuilder {
+    constructor(promiseService: any);
+    promiseService: any;
+    azureImageReader: AzureImageReader;
+    azureServerGroupTransformer: AzureServerGroupTransformer;
+    resolve(value: any): any;
+    buildNewServerGroupCommand(application: any, defaults: any): Promise<{
+        application: any;
+        credentials: any;
+        region: any;
+        images: any;
+        loadBalancers: any[];
+        selectedVnetSubnets: any[];
+        strategy: string;
+        sku: {
+            capacity: number;
+        };
+        zonesEnabled: boolean;
+        zones: any[];
+        instanceTags: {};
+        dataDisks: any[];
+        selectedProvider: string;
+        viewState: {
+            instanceProfile: string;
+            allImageSelection: any;
+            useAllImageSelection: boolean;
+            useSimpleCapacity: boolean;
+            usePreferredZones: boolean;
+            mode: any;
+            disableStrategySelection: boolean;
+            loadBalancersConfigured: boolean;
+            networkSettingsConfigured: boolean;
+            securityGroupsConfigured: boolean;
+        };
+        enableInboundNAT: boolean;
+    }>;
+    buildNewServerGroupCommandForPipeline(): any;
+    buildServerGroupCommandFromExisting(application: any, serverGroup: any, mode: any): Promise<{
+        application: any;
+        strategy: string;
+        stack: string;
+        freeFormDetails: string;
+        credentials: any;
+        loadBalancers: any;
+        selectedSubnets: any;
+        selectedVnet: any;
+        securityGroups: any;
+        loadBalancerName: any;
+        loadBalancerType: any;
+        securityGroupName: any;
+        region: any;
+        vnet: any;
+        vnetResourceGroup: any;
+        subnet: any;
+        zones: any;
+        zonesEnabled: boolean;
+        instanceTags: {};
+        dataDisks: any;
+        sku: any;
+        capacity: {
+            min: any;
+            max: any;
+            desired: any;
+        };
+        tags: any[];
+        instanceType: any;
+        selectedProvider: string;
+        source: {
+            account: any;
+            region: any;
+            serverGroupName: any;
+            asgName: any;
+        };
+        viewState: {
+            allImageSelection: any;
+            useAllImageSelection: boolean;
+            useSimpleCapacity: boolean;
+            usePreferredZones: boolean;
+            listImplicitSecurityGroups: boolean;
+            mode: any;
+            disableStrategySelection: boolean;
+        };
+        enableInboundNAT: any;
+    }>;
+    buildServerGroupCommandFromPipeline(application: any, originalCluster: any): Promise<any>;
+}
+import { AzureImageReader } from '../../image/image.reader';
+import { AzureServerGroupTransformer } from '../serverGroup.transformer';