@azure/arm-security 4.0.1-alpha.20220331.1 → 5.0.0

package/src/operations/alerts.ts

@@ -12,8 +12,6 @@ import * as coreClient from "@azure/core-client";
 import * as Mappers from "../models/mappers";
 import * as Parameters from "../models/parameters";
 import { SecurityCenter } from "../securityCenter";
-import { PollerLike, PollOperationState, LroEngine } from "@azure/core-lro";
-import { LroImpl } from "../lroImpl";
 import {
   Alert,
   AlertsListNextOptionalParams,
@@ -157,12 +155,18 @@ export class AlertsImpl implements Alerts {
 
   /**
    * List all the alerts that are associated with the subscription that are stored in a specific location
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param options The options parameters.
    */
   public listSubscriptionLevelByRegion(
+    ascLocation: string,
     options?: AlertsListSubscriptionLevelByRegionOptionalParams
   ): PagedAsyncIterableIterator<Alert> {
-    const iter = this.listSubscriptionLevelByRegionPagingAll(options);
+    const iter = this.listSubscriptionLevelByRegionPagingAll(
+      ascLocation,
+      options
+    );
     return {
       next() {
         return iter.next();
@@ -171,19 +175,27 @@ export class AlertsImpl implements Alerts {
         return this;
       },
       byPage: () => {
-        return this.listSubscriptionLevelByRegionPagingPage(options);
+        return this.listSubscriptionLevelByRegionPagingPage(
+          ascLocation,
+          options
+        );
       }
     };
   }
 
   private async *listSubscriptionLevelByRegionPagingPage(
+    ascLocation: string,
     options?: AlertsListSubscriptionLevelByRegionOptionalParams
   ): AsyncIterableIterator<Alert[]> {
-    let result = await this._listSubscriptionLevelByRegion(options);
+    let result = await this._listSubscriptionLevelByRegion(
+      ascLocation,
+      options
+    );
     yield result.value || [];
     let continuationToken = result.nextLink;
     while (continuationToken) {
       result = await this._listSubscriptionLevelByRegionNext(
+        ascLocation,
         continuationToken,
         options
       );
@@ -193,9 +205,11 @@ export class AlertsImpl implements Alerts {
   }
 
   private async *listSubscriptionLevelByRegionPagingAll(
+    ascLocation: string,
     options?: AlertsListSubscriptionLevelByRegionOptionalParams
   ): AsyncIterableIterator<Alert> {
     for await (const page of this.listSubscriptionLevelByRegionPagingPage(
+      ascLocation,
       options
     )) {
       yield* page;
@@ -205,15 +219,19 @@ export class AlertsImpl implements Alerts {
   /**
    * List all the alerts that are associated with the resource group that are stored in a specific
    * location
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   public listResourceGroupLevelByRegion(
+    ascLocation: string,
     resourceGroupName: string,
     options?: AlertsListResourceGroupLevelByRegionOptionalParams
   ): PagedAsyncIterableIterator<Alert> {
     const iter = this.listResourceGroupLevelByRegionPagingAll(
+      ascLocation,
       resourceGroupName,
       options
     );
@@ -226,6 +244,7 @@ export class AlertsImpl implements Alerts {
       },
       byPage: () => {
         return this.listResourceGroupLevelByRegionPagingPage(
+          ascLocation,
           resourceGroupName,
           options
         );
@@ -234,10 +253,12 @@ export class AlertsImpl implements Alerts {
   }
 
   private async *listResourceGroupLevelByRegionPagingPage(
+    ascLocation: string,
     resourceGroupName: string,
     options?: AlertsListResourceGroupLevelByRegionOptionalParams
   ): AsyncIterableIterator<Alert[]> {
     let result = await this._listResourceGroupLevelByRegion(
+      ascLocation,
       resourceGroupName,
       options
     );
@@ -245,6 +266,7 @@ export class AlertsImpl implements Alerts {
     let continuationToken = result.nextLink;
     while (continuationToken) {
       result = await this._listResourceGroupLevelByRegionNext(
+        ascLocation,
         resourceGroupName,
         continuationToken,
         options
@@ -255,10 +277,12 @@ export class AlertsImpl implements Alerts {
   }
 
   private async *listResourceGroupLevelByRegionPagingAll(
+    ascLocation: string,
     resourceGroupName: string,
     options?: AlertsListResourceGroupLevelByRegionOptionalParams
   ): AsyncIterableIterator<Alert> {
     for await (const page of this.listResourceGroupLevelByRegionPagingPage(
+      ascLocation,
       resourceGroupName,
       options
     )) {
@@ -294,13 +318,16 @@ export class AlertsImpl implements Alerts {
 
   /**
    * List all the alerts that are associated with the subscription that are stored in a specific location
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param options The options parameters.
    */
   private _listSubscriptionLevelByRegion(
+    ascLocation: string,
     options?: AlertsListSubscriptionLevelByRegionOptionalParams
   ): Promise<AlertsListSubscriptionLevelByRegionResponse> {
     return this.client.sendOperationRequest(
-      { options },
+      { ascLocation, options },
       listSubscriptionLevelByRegionOperationSpec
     );
   }
@@ -308,223 +335,195 @@ export class AlertsImpl implements Alerts {
   /**
    * List all the alerts that are associated with the resource group that are stored in a specific
    * location
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   private _listResourceGroupLevelByRegion(
+    ascLocation: string,
     resourceGroupName: string,
     options?: AlertsListResourceGroupLevelByRegionOptionalParams
   ): Promise<AlertsListResourceGroupLevelByRegionResponse> {
     return this.client.sendOperationRequest(
-      { resourceGroupName, options },
+      { ascLocation, resourceGroupName, options },
       listResourceGroupLevelByRegionOperationSpec
     );
   }
 
   /**
    * Get an alert that is associated with a subscription
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param options The options parameters.
    */
   getSubscriptionLevel(
+    ascLocation: string,
     alertName: string,
     options?: AlertsGetSubscriptionLevelOptionalParams
   ): Promise<AlertsGetSubscriptionLevelResponse> {
     return this.client.sendOperationRequest(
-      { alertName, options },
+      { ascLocation, alertName, options },
       getSubscriptionLevelOperationSpec
     );
   }
 
   /**
    * Get an alert that is associated a resource group or a resource in a resource group
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   getResourceGroupLevel(
+    ascLocation: string,
     alertName: string,
     resourceGroupName: string,
     options?: AlertsGetResourceGroupLevelOptionalParams
   ): Promise<AlertsGetResourceGroupLevelResponse> {
     return this.client.sendOperationRequest(
-      { alertName, resourceGroupName, options },
+      { ascLocation, alertName, resourceGroupName, options },
       getResourceGroupLevelOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param options The options parameters.
    */
   updateSubscriptionLevelStateToDismiss(
+    ascLocation: string,
     alertName: string,
     options?: AlertsUpdateSubscriptionLevelStateToDismissOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, options },
+      { ascLocation, alertName, options },
       updateSubscriptionLevelStateToDismissOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param options The options parameters.
    */
   updateSubscriptionLevelStateToResolve(
+    ascLocation: string,
     alertName: string,
     options?: AlertsUpdateSubscriptionLevelStateToResolveOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, options },
+      { ascLocation, alertName, options },
       updateSubscriptionLevelStateToResolveOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param options The options parameters.
    */
   updateSubscriptionLevelStateToActivate(
+    ascLocation: string,
     alertName: string,
     options?: AlertsUpdateSubscriptionLevelStateToActivateOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, options },
+      { ascLocation, alertName, options },
       updateSubscriptionLevelStateToActivateOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   updateResourceGroupLevelStateToResolve(
+    ascLocation: string,
     alertName: string,
     resourceGroupName: string,
     options?: AlertsUpdateResourceGroupLevelStateToResolveOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, resourceGroupName, options },
+      { ascLocation, alertName, resourceGroupName, options },
       updateResourceGroupLevelStateToResolveOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   updateResourceGroupLevelStateToDismiss(
+    ascLocation: string,
     alertName: string,
     resourceGroupName: string,
     options?: AlertsUpdateResourceGroupLevelStateToDismissOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, resourceGroupName, options },
+      { ascLocation, alertName, resourceGroupName, options },
       updateResourceGroupLevelStateToDismissOperationSpec
     );
   }
 
   /**
    * Update the alert's state
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertName Name of the alert object
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param options The options parameters.
    */
   updateResourceGroupLevelStateToActivate(
+    ascLocation: string,
     alertName: string,
     resourceGroupName: string,
     options?: AlertsUpdateResourceGroupLevelStateToActivateOptionalParams
   ): Promise<void> {
     return this.client.sendOperationRequest(
-      { alertName, resourceGroupName, options },
+      { ascLocation, alertName, resourceGroupName, options },
       updateResourceGroupLevelStateToActivateOperationSpec
     );
   }
 
   /**
    * Simulate security alerts
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param alertSimulatorRequestBody Alert Simulator Request Properties
    * @param options The options parameters.
    */
-  async beginSimulate(
+  simulate(
+    ascLocation: string,
     alertSimulatorRequestBody: AlertSimulatorRequestBody,
     options?: AlertsSimulateOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
-    const directSendOperation = async (
-      args: coreClient.OperationArguments,
-      spec: coreClient.OperationSpec
-    ): Promise<void> => {
-      return this.client.sendOperationRequest(args, spec);
-    };
-    const sendOperation = async (
-      args: coreClient.OperationArguments,
-      spec: coreClient.OperationSpec
-    ) => {
-      let currentRawResponse:
-        | coreClient.FullOperationResponse
-        | undefined = undefined;
-      const providedCallback = args.options?.onResponse;
-      const callback: coreClient.RawResponseCallback = (
-        rawResponse: coreClient.FullOperationResponse,
-        flatResponse: unknown
-      ) => {
-        currentRawResponse = rawResponse;
-        providedCallback?.(rawResponse, flatResponse);
-      };
-      const updatedArgs = {
-        ...args,
-        options: {
-          ...args.options,
-          onResponse: callback
-        }
-      };
-      const flatResponse = await directSendOperation(updatedArgs, spec);
-      return {
-        flatResponse,
-        rawResponse: {
-          statusCode: currentRawResponse!.status,
-          body: currentRawResponse!.parsedBody,
-          headers: currentRawResponse!.headers.toJSON()
-        }
-      };
-    };
-
-    const lro = new LroImpl(
-      sendOperation,
-      { alertSimulatorRequestBody, options },
+  ): Promise<void> {
+    return this.client.sendOperationRequest(
+      { ascLocation, alertSimulatorRequestBody, options },
       simulateOperationSpec
     );
-    return new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
-      intervalInMs: options?.updateIntervalInMs,
-      lroResourceLocationConfig: "original-uri"
-    });
-  }
-
-  /**
-   * Simulate security alerts
-   * @param alertSimulatorRequestBody Alert Simulator Request Properties
-   * @param options The options parameters.
-   */
-  async beginSimulateAndWait(
-    alertSimulatorRequestBody: AlertSimulatorRequestBody,
-    options?: AlertsSimulateOptionalParams
-  ): Promise<void> {
-    const poller = await this.beginSimulate(alertSimulatorRequestBody, options);
-    return poller.pollUntilDone();
   }
 
   /**
@@ -562,22 +561,27 @@ export class AlertsImpl implements Alerts {
 
   /**
    * ListSubscriptionLevelByRegionNext
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param nextLink The nextLink from the previous successful call to the ListSubscriptionLevelByRegion
    *                 method.
    * @param options The options parameters.
    */
   private _listSubscriptionLevelByRegionNext(
+    ascLocation: string,
     nextLink: string,
     options?: AlertsListSubscriptionLevelByRegionNextOptionalParams
   ): Promise<AlertsListSubscriptionLevelByRegionNextResponse> {
     return this.client.sendOperationRequest(
-      { nextLink, options },
+      { ascLocation, nextLink, options },
       listSubscriptionLevelByRegionNextOperationSpec
     );
   }
 
   /**
    * ListResourceGroupLevelByRegionNext
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
    * @param nextLink The nextLink from the previous successful call to the ListResourceGroupLevelByRegion
@@ -585,12 +589,13 @@ export class AlertsImpl implements Alerts {
    * @param options The options parameters.
    */
   private _listResourceGroupLevelByRegionNext(
+    ascLocation: string,
     resourceGroupName: string,
     nextLink: string,
     options?: AlertsListResourceGroupLevelByRegionNextOptionalParams
   ): Promise<AlertsListResourceGroupLevelByRegionNextResponse> {
     return this.client.sendOperationRequest(
-      { resourceGroupName, nextLink, options },
+      { ascLocation, resourceGroupName, nextLink, options },
       listResourceGroupLevelByRegionNextOperationSpec
     );
   }
@@ -851,9 +856,6 @@ const simulateOperationSpec: coreClient.OperationSpec = {
     "/subscriptions/{subscriptionId}/providers/Microsoft.Security/locations/{ascLocation}/alerts/default/simulate",
   httpMethod: "POST",
   responses: {
-    200: {},
-    201: {},
-    202: {},
     204: {},
     default: {
       bodyMapper: Mappers.CloudError

package/src/operations/allowedConnections.ts

@@ -84,12 +84,15 @@ export class AllowedConnectionsImpl implements AllowedConnections {
 
   /**
    * Gets the list of all possible traffic between resources for the subscription and location.
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param options The options parameters.
    */
   public listByHomeRegion(
+    ascLocation: string,
     options?: AllowedConnectionsListByHomeRegionOptionalParams
   ): PagedAsyncIterableIterator<AllowedConnectionsResource> {
-    const iter = this.listByHomeRegionPagingAll(options);
+    const iter = this.listByHomeRegionPagingAll(ascLocation, options);
     return {
       next() {
         return iter.next();
@@ -98,28 +101,37 @@ export class AllowedConnectionsImpl implements AllowedConnections {
         return this;
       },
       byPage: () => {
-        return this.listByHomeRegionPagingPage(options);
+        return this.listByHomeRegionPagingPage(ascLocation, options);
       }
     };
   }
 
   private async *listByHomeRegionPagingPage(
+    ascLocation: string,
     options?: AllowedConnectionsListByHomeRegionOptionalParams
   ): AsyncIterableIterator<AllowedConnectionsResource[]> {
-    let result = await this._listByHomeRegion(options);
+    let result = await this._listByHomeRegion(ascLocation, options);
     yield result.value || [];
     let continuationToken = result.nextLink;
     while (continuationToken) {
-      result = await this._listByHomeRegionNext(continuationToken, options);
+      result = await this._listByHomeRegionNext(
+        ascLocation,
+        continuationToken,
+        options
+      );
       continuationToken = result.nextLink;
       yield result.value || [];
     }
   }
 
   private async *listByHomeRegionPagingAll(
+    ascLocation: string,
     options?: AllowedConnectionsListByHomeRegionOptionalParams
   ): AsyncIterableIterator<AllowedConnectionsResource> {
-    for await (const page of this.listByHomeRegionPagingPage(options)) {
+    for await (const page of this.listByHomeRegionPagingPage(
+      ascLocation,
+      options
+    )) {
       yield* page;
     }
   }
@@ -136,13 +148,16 @@ export class AllowedConnectionsImpl implements AllowedConnections {
 
   /**
    * Gets the list of all possible traffic between resources for the subscription and location.
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param options The options parameters.
    */
   private _listByHomeRegion(
+    ascLocation: string,
     options?: AllowedConnectionsListByHomeRegionOptionalParams
   ): Promise<AllowedConnectionsListByHomeRegionResponse> {
     return this.client.sendOperationRequest(
-      { options },
+      { ascLocation, options },
       listByHomeRegionOperationSpec
     );
   }
@@ -152,16 +167,19 @@ export class AllowedConnectionsImpl implements AllowedConnections {
    * connection type.
    * @param resourceGroupName The name of the resource group within the user's subscription. The name is
    *                          case insensitive.
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param connectionType The type of allowed connections (Internal, External)
    * @param options The options parameters.
    */
   get(
     resourceGroupName: string,
+    ascLocation: string,
     connectionType: ConnectionType,
     options?: AllowedConnectionsGetOptionalParams
   ): Promise<AllowedConnectionsGetResponse> {
     return this.client.sendOperationRequest(
-      { resourceGroupName, connectionType, options },
+      { resourceGroupName, ascLocation, connectionType, options },
       getOperationSpec
     );
   }
@@ -183,15 +201,18 @@ export class AllowedConnectionsImpl implements AllowedConnections {
 
   /**
    * ListByHomeRegionNext
+   * @param ascLocation The location where ASC stores the data of the subscription. can be retrieved from
+   *                    Get locations
    * @param nextLink The nextLink from the previous successful call to the ListByHomeRegion method.
    * @param options The options parameters.
    */
   private _listByHomeRegionNext(
+    ascLocation: string,
     nextLink: string,
     options?: AllowedConnectionsListByHomeRegionNextOptionalParams
   ): Promise<AllowedConnectionsListByHomeRegionNextResponse> {
     return this.client.sendOperationRequest(
-      { nextLink, options },
+      { ascLocation, nextLink, options },
       listByHomeRegionNextOperationSpec
     );
   }