@azure/arm-policyinsights 6.0.0 → 7.0.0-beta.1

package/dist/commonjs/api/policyStates/operations.js

@@ -0,0 +1,989 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+__export(operations_exports, {
+  _listQueryResultsForManagementGroupDeserialize: () => _listQueryResultsForManagementGroupDeserialize,
+  _listQueryResultsForManagementGroupSend: () => _listQueryResultsForManagementGroupSend,
+  _listQueryResultsForPolicyDefinitionDeserialize: () => _listQueryResultsForPolicyDefinitionDeserialize,
+  _listQueryResultsForPolicyDefinitionSend: () => _listQueryResultsForPolicyDefinitionSend,
+  _listQueryResultsForPolicySetDefinitionDeserialize: () => _listQueryResultsForPolicySetDefinitionDeserialize,
+  _listQueryResultsForPolicySetDefinitionSend: () => _listQueryResultsForPolicySetDefinitionSend,
+  _listQueryResultsForResourceDeserialize: () => _listQueryResultsForResourceDeserialize,
+  _listQueryResultsForResourceGroupDeserialize: () => _listQueryResultsForResourceGroupDeserialize,
+  _listQueryResultsForResourceGroupLevelPolicyAssignmentDeserialize: () => _listQueryResultsForResourceGroupLevelPolicyAssignmentDeserialize,
+  _listQueryResultsForResourceGroupLevelPolicyAssignmentSend: () => _listQueryResultsForResourceGroupLevelPolicyAssignmentSend,
+  _listQueryResultsForResourceGroupSend: () => _listQueryResultsForResourceGroupSend,
+  _listQueryResultsForResourceSend: () => _listQueryResultsForResourceSend,
+  _listQueryResultsForSubscriptionDeserialize: () => _listQueryResultsForSubscriptionDeserialize,
+  _listQueryResultsForSubscriptionLevelPolicyAssignmentDeserialize: () => _listQueryResultsForSubscriptionLevelPolicyAssignmentDeserialize,
+  _listQueryResultsForSubscriptionLevelPolicyAssignmentSend: () => _listQueryResultsForSubscriptionLevelPolicyAssignmentSend,
+  _listQueryResultsForSubscriptionSend: () => _listQueryResultsForSubscriptionSend,
+  _summarizeForManagementGroupDeserialize: () => _summarizeForManagementGroupDeserialize,
+  _summarizeForManagementGroupSend: () => _summarizeForManagementGroupSend,
+  _summarizeForPolicyDefinitionDeserialize: () => _summarizeForPolicyDefinitionDeserialize,
+  _summarizeForPolicyDefinitionSend: () => _summarizeForPolicyDefinitionSend,
+  _summarizeForPolicySetDefinitionDeserialize: () => _summarizeForPolicySetDefinitionDeserialize,
+  _summarizeForPolicySetDefinitionSend: () => _summarizeForPolicySetDefinitionSend,
+  _summarizeForResourceDeserialize: () => _summarizeForResourceDeserialize,
+  _summarizeForResourceGroupDeserialize: () => _summarizeForResourceGroupDeserialize,
+  _summarizeForResourceGroupLevelPolicyAssignmentDeserialize: () => _summarizeForResourceGroupLevelPolicyAssignmentDeserialize,
+  _summarizeForResourceGroupLevelPolicyAssignmentSend: () => _summarizeForResourceGroupLevelPolicyAssignmentSend,
+  _summarizeForResourceGroupSend: () => _summarizeForResourceGroupSend,
+  _summarizeForResourceSend: () => _summarizeForResourceSend,
+  _summarizeForSubscriptionDeserialize: () => _summarizeForSubscriptionDeserialize,
+  _summarizeForSubscriptionLevelPolicyAssignmentDeserialize: () => _summarizeForSubscriptionLevelPolicyAssignmentDeserialize,
+  _summarizeForSubscriptionLevelPolicyAssignmentSend: () => _summarizeForSubscriptionLevelPolicyAssignmentSend,
+  _summarizeForSubscriptionSend: () => _summarizeForSubscriptionSend,
+  _triggerResourceGroupEvaluationDeserialize: () => _triggerResourceGroupEvaluationDeserialize,
+  _triggerResourceGroupEvaluationSend: () => _triggerResourceGroupEvaluationSend,
+  _triggerSubscriptionEvaluationDeserialize: () => _triggerSubscriptionEvaluationDeserialize,
+  _triggerSubscriptionEvaluationSend: () => _triggerSubscriptionEvaluationSend,
+  listQueryResultsForManagementGroup: () => listQueryResultsForManagementGroup,
+  listQueryResultsForPolicyDefinition: () => listQueryResultsForPolicyDefinition,
+  listQueryResultsForPolicySetDefinition: () => listQueryResultsForPolicySetDefinition,
+  listQueryResultsForResource: () => listQueryResultsForResource,
+  listQueryResultsForResourceGroup: () => listQueryResultsForResourceGroup,
+  listQueryResultsForResourceGroupLevelPolicyAssignment: () => listQueryResultsForResourceGroupLevelPolicyAssignment,
+  listQueryResultsForSubscription: () => listQueryResultsForSubscription,
+  listQueryResultsForSubscriptionLevelPolicyAssignment: () => listQueryResultsForSubscriptionLevelPolicyAssignment,
+  summarizeForManagementGroup: () => summarizeForManagementGroup,
+  summarizeForPolicyDefinition: () => summarizeForPolicyDefinition,
+  summarizeForPolicySetDefinition: () => summarizeForPolicySetDefinition,
+  summarizeForResource: () => summarizeForResource,
+  summarizeForResourceGroup: () => summarizeForResourceGroup,
+  summarizeForResourceGroupLevelPolicyAssignment: () => summarizeForResourceGroupLevelPolicyAssignment,
+  summarizeForSubscription: () => summarizeForSubscription,
+  summarizeForSubscriptionLevelPolicyAssignment: () => summarizeForSubscriptionLevelPolicyAssignment,
+  triggerResourceGroupEvaluation: () => triggerResourceGroupEvaluation,
+  triggerSubscriptionEvaluation: () => triggerSubscriptionEvaluation
+});
+module.exports = __toCommonJS(operations_exports);
+var import_models = require("../../models/policyInsightsApi/models.js");
+var import_models2 = require("../../models/policyInsightsCommon/models.js");
+var import_pagingHelpers = require("../../static-helpers/pagingHelpers.js");
+var import_pollingHelpers = require("../../static-helpers/pollingHelpers.js");
+var import_urlTemplate = require("../../static-helpers/urlTemplate.js");
+var import_core_client = require("@azure-rest/core-client");
+function _summarizeForResourceGroupLevelPolicyAssignmentSend(context, policyStatesSummaryResource, subscriptionId, resourceGroupName, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{authorizationNamespace}/policyAssignments/{policyAssignmentName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      resourceGroupName,
+      policyStatesSummaryResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyAssignmentName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForResourceGroupLevelPolicyAssignmentDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForResourceGroupLevelPolicyAssignment(context, policyStatesSummaryResource, subscriptionId, resourceGroupName, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const result = await _summarizeForResourceGroupLevelPolicyAssignmentSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    resourceGroupName,
+    policyAssignmentName,
+    options
+  );
+  return _summarizeForResourceGroupLevelPolicyAssignmentDeserialize(result);
+}
+function _listQueryResultsForResourceGroupLevelPolicyAssignmentSend(context, policyStatesResource, subscriptionId, resourceGroupName, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{authorizationNamespace}/policyAssignments/{policyAssignmentName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      resourceGroupName,
+      policyStatesResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyAssignmentName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForResourceGroupLevelPolicyAssignmentDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForResourceGroupLevelPolicyAssignment(context, policyStatesResource, subscriptionId, resourceGroupName, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForResourceGroupLevelPolicyAssignmentSend(
+      context,
+      policyStatesResource,
+      subscriptionId,
+      resourceGroupName,
+      policyAssignmentName,
+      options
+    ),
+    _listQueryResultsForResourceGroupLevelPolicyAssignmentDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForSubscriptionLevelPolicyAssignmentSend(context, policyStatesSummaryResource, subscriptionId, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policyAssignments/{policyAssignmentName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      policyStatesSummaryResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyAssignmentName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForSubscriptionLevelPolicyAssignmentDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForSubscriptionLevelPolicyAssignment(context, policyStatesSummaryResource, subscriptionId, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const result = await _summarizeForSubscriptionLevelPolicyAssignmentSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    policyAssignmentName,
+    options
+  );
+  return _summarizeForSubscriptionLevelPolicyAssignmentDeserialize(result);
+}
+function _listQueryResultsForSubscriptionLevelPolicyAssignmentSend(context, policyStatesResource, subscriptionId, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policyAssignments/{policyAssignmentName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      policyStatesResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyAssignmentName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForSubscriptionLevelPolicyAssignmentDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForSubscriptionLevelPolicyAssignment(context, policyStatesResource, subscriptionId, policyAssignmentName, options = {
+  requestOptions: {}
+}) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForSubscriptionLevelPolicyAssignmentSend(
+      context,
+      policyStatesResource,
+      subscriptionId,
+      policyAssignmentName,
+      options
+    ),
+    _listQueryResultsForSubscriptionLevelPolicyAssignmentDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForPolicyDefinitionSend(context, policyStatesSummaryResource, subscriptionId, policyDefinitionName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policyDefinitions/{policyDefinitionName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      policyStatesSummaryResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyDefinitionName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForPolicyDefinitionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForPolicyDefinition(context, policyStatesSummaryResource, subscriptionId, policyDefinitionName, options = { requestOptions: {} }) {
+  const result = await _summarizeForPolicyDefinitionSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    policyDefinitionName,
+    options
+  );
+  return _summarizeForPolicyDefinitionDeserialize(result);
+}
+function _listQueryResultsForPolicyDefinitionSend(context, policyStatesResource, subscriptionId, policyDefinitionName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policyDefinitions/{policyDefinitionName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      policyStatesResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policyDefinitionName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForPolicyDefinitionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForPolicyDefinition(context, policyStatesResource, subscriptionId, policyDefinitionName, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForPolicyDefinitionSend(
+      context,
+      policyStatesResource,
+      subscriptionId,
+      policyDefinitionName,
+      options
+    ),
+    _listQueryResultsForPolicyDefinitionDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForPolicySetDefinitionSend(context, policyStatesSummaryResource, subscriptionId, policySetDefinitionName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policySetDefinitions/{policySetDefinitionName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      policyStatesSummaryResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policySetDefinitionName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForPolicySetDefinitionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForPolicySetDefinition(context, policyStatesSummaryResource, subscriptionId, policySetDefinitionName, options = { requestOptions: {} }) {
+  const result = await _summarizeForPolicySetDefinitionSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    policySetDefinitionName,
+    options
+  );
+  return _summarizeForPolicySetDefinitionDeserialize(result);
+}
+function _listQueryResultsForPolicySetDefinitionSend(context, policyStatesResource, subscriptionId, policySetDefinitionName, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/{authorizationNamespace}/policySetDefinitions/{policySetDefinitionName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      policyStatesResource,
+      authorizationNamespace: "Microsoft.Authorization",
+      policySetDefinitionName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForPolicySetDefinitionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForPolicySetDefinition(context, policyStatesResource, subscriptionId, policySetDefinitionName, options = {
+  requestOptions: {}
+}) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForPolicySetDefinitionSend(
+      context,
+      policyStatesResource,
+      subscriptionId,
+      policySetDefinitionName,
+      options
+    ),
+    _listQueryResultsForPolicySetDefinitionDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _triggerResourceGroupEvaluationSend(context, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.PolicyInsights/policyStates/latest/triggerEvaluation{?api%2Dversion}",
+    {
+      subscriptionId,
+      resourceGroupName,
+      "api%2Dversion": "2024-10-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _triggerResourceGroupEvaluationDeserialize(result) {
+  const expectedStatuses = ["200", "202", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return;
+}
+function triggerResourceGroupEvaluation(context, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  return (0, import_pollingHelpers.getLongRunningPoller)(
+    context,
+    _triggerResourceGroupEvaluationDeserialize,
+    ["200", "202", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _triggerResourceGroupEvaluationSend(context, subscriptionId, resourceGroupName, options),
+      resourceLocationConfig: "location",
+      apiVersion: "2024-10-01"
+    }
+  );
+}
+function _triggerSubscriptionEvaluationSend(context, subscriptionId, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.PolicyInsights/policyStates/latest/triggerEvaluation{?api%2Dversion}",
+    {
+      subscriptionId,
+      "api%2Dversion": "2024-10-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _triggerSubscriptionEvaluationDeserialize(result) {
+  const expectedStatuses = ["200", "202", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return;
+}
+function triggerSubscriptionEvaluation(context, subscriptionId, options = { requestOptions: {} }) {
+  return (0, import_pollingHelpers.getLongRunningPoller)(
+    context,
+    _triggerSubscriptionEvaluationDeserialize,
+    ["200", "202", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _triggerSubscriptionEvaluationSend(context, subscriptionId, options),
+      resourceLocationConfig: "location",
+      apiVersion: "2024-10-01"
+    }
+  );
+}
+function _summarizeForResourceSend(context, policyStatesSummaryResource, resourceId, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/{+resourceId}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      policyStatesSummaryResource,
+      resourceId,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForResourceDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForResource(context, policyStatesSummaryResource, resourceId, options = { requestOptions: {} }) {
+  const result = await _summarizeForResourceSend(
+    context,
+    policyStatesSummaryResource,
+    resourceId,
+    options
+  );
+  return _summarizeForResourceDeserialize(result);
+}
+function _listQueryResultsForResourceSend(context, policyStatesResource, resourceId, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/{+resourceId}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24expand,%24skiptoken}",
+    {
+      policyStatesResource,
+      resourceId,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24expand": options?.queryOptions?.expand,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForResourceDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForResource(context, policyStatesResource, resourceId, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForResourceSend(context, policyStatesResource, resourceId, options),
+    _listQueryResultsForResourceDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForResourceGroupSend(context, policyStatesSummaryResource, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      resourceGroupName,
+      policyStatesSummaryResource,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForResourceGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForResourceGroup(context, policyStatesSummaryResource, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  const result = await _summarizeForResourceGroupSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    resourceGroupName,
+    options
+  );
+  return _summarizeForResourceGroupDeserialize(result);
+}
+function _listQueryResultsForResourceGroupSend(context, policyStatesResource, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      resourceGroupName,
+      policyStatesResource,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForResourceGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForResourceGroup(context, policyStatesResource, subscriptionId, resourceGroupName, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForResourceGroupSend(
+      context,
+      policyStatesResource,
+      subscriptionId,
+      resourceGroupName,
+      options
+    ),
+    _listQueryResultsForResourceGroupDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForSubscriptionSend(context, policyStatesSummaryResource, subscriptionId, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      subscriptionId,
+      policyStatesSummaryResource,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForSubscriptionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForSubscription(context, policyStatesSummaryResource, subscriptionId, options = { requestOptions: {} }) {
+  const result = await _summarizeForSubscriptionSend(
+    context,
+    policyStatesSummaryResource,
+    subscriptionId,
+    options
+  );
+  return _summarizeForSubscriptionDeserialize(result);
+}
+function _listQueryResultsForSubscriptionSend(context, policyStatesResource, subscriptionId, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      subscriptionId,
+      policyStatesResource,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForSubscriptionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForSubscription(context, policyStatesResource, subscriptionId, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForSubscriptionSend(context, policyStatesResource, subscriptionId, options),
+    _listQueryResultsForSubscriptionDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+function _summarizeForManagementGroupSend(context, policyStatesSummaryResource, managementGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/providers/{managementGroupsNamespace}/managementGroups/{managementGroupName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesSummaryResource}/summarize{?api%2Dversion,%24top,%24from,%24to,%24filter}",
+    {
+      policyStatesSummaryResource,
+      managementGroupsNamespace: "Microsoft.Management",
+      managementGroupName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _summarizeForManagementGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models.summarizeResultsDeserializer)(result.body);
+}
+async function summarizeForManagementGroup(context, policyStatesSummaryResource, managementGroupName, options = { requestOptions: {} }) {
+  const result = await _summarizeForManagementGroupSend(
+    context,
+    policyStatesSummaryResource,
+    managementGroupName,
+    options
+  );
+  return _summarizeForManagementGroupDeserialize(result);
+}
+function _listQueryResultsForManagementGroupSend(context, policyStatesResource, managementGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/providers/{managementGroupsNamespace}/managementGroups/{managementGroupName}/providers/Microsoft.PolicyInsights/policyStates/{policyStatesResource}/queryResults{?api%2Dversion,%24top,%24orderby,%24select,%24from,%24to,%24filter,%24apply,%24skiptoken}",
+    {
+      policyStatesResource,
+      managementGroupsNamespace: "Microsoft.Management",
+      managementGroupName,
+      "api%2Dversion": "2024-10-01",
+      "%24top": options?.queryOptions?.top,
+      "%24orderby": options?.queryOptions?.orderBy,
+      "%24select": options?.queryOptions?.select,
+      "%24from": !options?.queryOptions?.from ? options?.queryOptions?.from : options?.queryOptions?.from.toISOString(),
+      "%24to": !options?.queryOptions?.to ? options?.queryOptions?.to : options?.queryOptions?.to.toISOString(),
+      "%24filter": options?.queryOptions?.filter,
+      "%24apply": options?.queryOptions?.apply,
+      "%24skiptoken": options?.queryOptions?.skipToken
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listQueryResultsForManagementGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    if (result.body) {
+      error.details = (0, import_models2.queryFailureDeserializer)(result.body);
+    }
+    throw error;
+  }
+  return (0, import_models._policyStatesQueryResultsDeserializer)(result.body);
+}
+function listQueryResultsForManagementGroup(context, policyStatesResource, managementGroupName, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listQueryResultsForManagementGroupSend(
+      context,
+      policyStatesResource,
+      managementGroupName,
+      options
+    ),
+    _listQueryResultsForManagementGroupDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "@odata.nextLink", apiVersion: "2024-10-01" }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _listQueryResultsForManagementGroupDeserialize,
+  _listQueryResultsForManagementGroupSend,
+  _listQueryResultsForPolicyDefinitionDeserialize,
+  _listQueryResultsForPolicyDefinitionSend,
+  _listQueryResultsForPolicySetDefinitionDeserialize,
+  _listQueryResultsForPolicySetDefinitionSend,
+  _listQueryResultsForResourceDeserialize,
+  _listQueryResultsForResourceGroupDeserialize,
+  _listQueryResultsForResourceGroupLevelPolicyAssignmentDeserialize,
+  _listQueryResultsForResourceGroupLevelPolicyAssignmentSend,
+  _listQueryResultsForResourceGroupSend,
+  _listQueryResultsForResourceSend,
+  _listQueryResultsForSubscriptionDeserialize,
+  _listQueryResultsForSubscriptionLevelPolicyAssignmentDeserialize,
+  _listQueryResultsForSubscriptionLevelPolicyAssignmentSend,
+  _listQueryResultsForSubscriptionSend,
+  _summarizeForManagementGroupDeserialize,
+  _summarizeForManagementGroupSend,
+  _summarizeForPolicyDefinitionDeserialize,
+  _summarizeForPolicyDefinitionSend,
+  _summarizeForPolicySetDefinitionDeserialize,
+  _summarizeForPolicySetDefinitionSend,
+  _summarizeForResourceDeserialize,
+  _summarizeForResourceGroupDeserialize,
+  _summarizeForResourceGroupLevelPolicyAssignmentDeserialize,
+  _summarizeForResourceGroupLevelPolicyAssignmentSend,
+  _summarizeForResourceGroupSend,
+  _summarizeForResourceSend,
+  _summarizeForSubscriptionDeserialize,
+  _summarizeForSubscriptionLevelPolicyAssignmentDeserialize,
+  _summarizeForSubscriptionLevelPolicyAssignmentSend,
+  _summarizeForSubscriptionSend,
+  _triggerResourceGroupEvaluationDeserialize,
+  _triggerResourceGroupEvaluationSend,
+  _triggerSubscriptionEvaluationDeserialize,
+  _triggerSubscriptionEvaluationSend,
+  listQueryResultsForManagementGroup,
+  listQueryResultsForPolicyDefinition,
+  listQueryResultsForPolicySetDefinition,
+  listQueryResultsForResource,
+  listQueryResultsForResourceGroup,
+  listQueryResultsForResourceGroupLevelPolicyAssignment,
+  listQueryResultsForSubscription,
+  listQueryResultsForSubscriptionLevelPolicyAssignment,
+  summarizeForManagementGroup,
+  summarizeForPolicyDefinition,
+  summarizeForPolicySetDefinition,
+  summarizeForResource,
+  summarizeForResourceGroup,
+  summarizeForResourceGroupLevelPolicyAssignment,
+  summarizeForSubscription,
+  summarizeForSubscriptionLevelPolicyAssignment,
+  triggerResourceGroupEvaluation,
+  triggerSubscriptionEvaluation
+});
+//# sourceMappingURL=operations.js.map