@azure/arm-certificateregistration 1.0.0-beta.1 → 1.0.0

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

@@ -0,0 +1,893 @@
+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, {
+  $delete: () => $delete,
+  _$deleteDeserialize: () => _$deleteDeserialize,
+  _$deleteSend: () => _$deleteSend,
+  _createOrUpdateCertificateDeserialize: () => _createOrUpdateCertificateDeserialize,
+  _createOrUpdateCertificateSend: () => _createOrUpdateCertificateSend,
+  _createOrUpdateDeserialize: () => _createOrUpdateDeserialize,
+  _createOrUpdateSend: () => _createOrUpdateSend,
+  _deleteCertificateDeserialize: () => _deleteCertificateDeserialize,
+  _deleteCertificateSend: () => _deleteCertificateSend,
+  _getCertificateDeserialize: () => _getCertificateDeserialize,
+  _getCertificateSend: () => _getCertificateSend,
+  _getDeserialize: () => _getDeserialize,
+  _getSend: () => _getSend,
+  _listByResourceGroupDeserialize: () => _listByResourceGroupDeserialize,
+  _listByResourceGroupSend: () => _listByResourceGroupSend,
+  _listCertificatesDeserialize: () => _listCertificatesDeserialize,
+  _listCertificatesSend: () => _listCertificatesSend,
+  _listDeserialize: () => _listDeserialize,
+  _listSend: () => _listSend,
+  _reissueDeserialize: () => _reissueDeserialize,
+  _reissueSend: () => _reissueSend,
+  _renewDeserialize: () => _renewDeserialize,
+  _renewSend: () => _renewSend,
+  _resendEmailDeserialize: () => _resendEmailDeserialize,
+  _resendEmailSend: () => _resendEmailSend,
+  _resendRequestEmailsDeserialize: () => _resendRequestEmailsDeserialize,
+  _resendRequestEmailsSend: () => _resendRequestEmailsSend,
+  _retrieveCertificateActionsDeserialize: () => _retrieveCertificateActionsDeserialize,
+  _retrieveCertificateActionsSend: () => _retrieveCertificateActionsSend,
+  _retrieveCertificateEmailHistoryDeserialize: () => _retrieveCertificateEmailHistoryDeserialize,
+  _retrieveCertificateEmailHistorySend: () => _retrieveCertificateEmailHistorySend,
+  _retrieveSiteSealDeserialize: () => _retrieveSiteSealDeserialize,
+  _retrieveSiteSealSend: () => _retrieveSiteSealSend,
+  _updateCertificateDeserialize: () => _updateCertificateDeserialize,
+  _updateCertificateSend: () => _updateCertificateSend,
+  _updateDeserialize: () => _updateDeserialize,
+  _updateSend: () => _updateSend,
+  _validatePurchaseInformationDeserialize: () => _validatePurchaseInformationDeserialize,
+  _validatePurchaseInformationSend: () => _validatePurchaseInformationSend,
+  _verifyDomainOwnershipDeserialize: () => _verifyDomainOwnershipDeserialize,
+  _verifyDomainOwnershipSend: () => _verifyDomainOwnershipSend,
+  createOrUpdate: () => createOrUpdate,
+  createOrUpdateCertificate: () => createOrUpdateCertificate,
+  deleteCertificate: () => deleteCertificate,
+  get: () => get,
+  getCertificate: () => getCertificate,
+  list: () => list,
+  listByResourceGroup: () => listByResourceGroup,
+  listCertificates: () => listCertificates,
+  reissue: () => reissue,
+  renew: () => renew,
+  resendEmail: () => resendEmail,
+  resendRequestEmails: () => resendRequestEmails,
+  retrieveCertificateActions: () => retrieveCertificateActions,
+  retrieveCertificateEmailHistory: () => retrieveCertificateEmailHistory,
+  retrieveSiteSeal: () => retrieveSiteSeal,
+  update: () => update,
+  updateCertificate: () => updateCertificate,
+  validatePurchaseInformation: () => validatePurchaseInformation,
+  verifyDomainOwnership: () => verifyDomainOwnership
+});
+module.exports = __toCommonJS(operations_exports);
+var import_models = require("../../models/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 _validatePurchaseInformationSend(context, appServiceCertificateOrder, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/validateCertificateRegistrationInformation{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    body: (0, import_models.appServiceCertificateOrderSerializer)(appServiceCertificateOrder)
+  });
+}
+async function _validatePurchaseInformationDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function validatePurchaseInformation(context, appServiceCertificateOrder, options = {
+  requestOptions: {}
+}) {
+  const result = await _validatePurchaseInformationSend(
+    context,
+    appServiceCertificateOrder,
+    options
+  );
+  return _validatePurchaseInformationDeserialize(result);
+}
+function _listCertificatesSend(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listCertificatesDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models._appServiceCertificateCollectionDeserializer)(result.body);
+}
+function listCertificates(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listCertificatesSend(context, resourceGroupName, certificateOrderName, options),
+    _listCertificatesDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2024-11-01" }
+  );
+}
+function _deleteCertificateSend(context, resourceGroupName, certificateOrderName, name, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).delete({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _deleteCertificateDeserialize(result) {
+  const expectedStatuses = ["200", "204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function deleteCertificate(context, resourceGroupName, certificateOrderName, name, options = { requestOptions: {} }) {
+  const result = await _deleteCertificateSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    name,
+    options
+  );
+  return _deleteCertificateDeserialize(result);
+}
+function _updateCertificateSend(context, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).patch({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: (0, import_models.appServiceCertificatePatchResourceSerializer)(keyVaultCertificate)
+  });
+}
+async function _updateCertificateDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateResourceDeserializer)(result.body);
+}
+async function updateCertificate(context, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options = { requestOptions: {} }) {
+  const result = await _updateCertificateSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    name,
+    keyVaultCertificate,
+    options
+  );
+  return _updateCertificateDeserialize(result);
+}
+function _createOrUpdateCertificateSend(context, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).put({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: (0, import_models.appServiceCertificateResourceSerializer)(keyVaultCertificate)
+  });
+}
+async function _createOrUpdateCertificateDeserialize(result) {
+  const expectedStatuses = ["200", "201", "202"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateResourceDeserializer)(result.body);
+}
+function createOrUpdateCertificate(context, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options = {
+  requestOptions: {}
+}) {
+  return (0, import_pollingHelpers.getLongRunningPoller)(
+    context,
+    _createOrUpdateCertificateDeserialize,
+    ["200", "201", "202"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _createOrUpdateCertificateSend(
+        context,
+        resourceGroupName,
+        certificateOrderName,
+        name,
+        keyVaultCertificate,
+        options
+      ),
+      resourceLocationConfig: "location",
+      apiVersion: context.apiVersion ?? "2024-11-01"
+    }
+  );
+}
+function _getCertificateSend(context, resourceGroupName, certificateOrderName, name, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getCertificateDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateResourceDeserializer)(result.body);
+}
+async function getCertificate(context, resourceGroupName, certificateOrderName, name, options = { requestOptions: {} }) {
+  const result = await _getCertificateSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    name,
+    options
+  );
+  return _getCertificateDeserialize(result);
+}
+function _retrieveCertificateEmailHistorySend(context, resourceGroupName, name, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveEmailHistory{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _retrieveCertificateEmailHistoryDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.certificateEmailArrayDeserializer)(result.body);
+}
+async function retrieveCertificateEmailHistory(context, resourceGroupName, name, options = {
+  requestOptions: {}
+}) {
+  const result = await _retrieveCertificateEmailHistorySend(
+    context,
+    resourceGroupName,
+    name,
+    options
+  );
+  return _retrieveCertificateEmailHistoryDeserialize(result);
+}
+function _retrieveCertificateActionsSend(context, resourceGroupName, name, options = {
+  requestOptions: {}
+}) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveCertificateActions{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      name,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _retrieveCertificateActionsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.certificateOrderActionArrayDeserializer)(result.body);
+}
+async function retrieveCertificateActions(context, resourceGroupName, name, options = {
+  requestOptions: {}
+}) {
+  const result = await _retrieveCertificateActionsSend(context, resourceGroupName, name, options);
+  return _retrieveCertificateActionsDeserialize(result);
+}
+function _verifyDomainOwnershipSend(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/verifyDomainOwnership{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _verifyDomainOwnershipDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function verifyDomainOwnership(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const result = await _verifyDomainOwnershipSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    options
+  );
+  return _verifyDomainOwnershipDeserialize(result);
+}
+function _retrieveSiteSealSend(context, resourceGroupName, certificateOrderName, siteSealRequest, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/retrieveSiteSeal{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: (0, import_models.siteSealRequestSerializer)(siteSealRequest)
+  });
+}
+async function _retrieveSiteSealDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.siteSealDeserializer)(result.body);
+}
+async function retrieveSiteSeal(context, resourceGroupName, certificateOrderName, siteSealRequest, options = { requestOptions: {} }) {
+  const result = await _retrieveSiteSealSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    siteSealRequest,
+    options
+  );
+  return _retrieveSiteSealDeserialize(result);
+}
+function _resendRequestEmailsSend(context, resourceGroupName, certificateOrderName, nameIdentifier, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendRequestEmails{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    body: (0, import_models.nameIdentifierSerializer)(nameIdentifier)
+  });
+}
+async function _resendRequestEmailsDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function resendRequestEmails(context, resourceGroupName, certificateOrderName, nameIdentifier, options = { requestOptions: {} }) {
+  const result = await _resendRequestEmailsSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    nameIdentifier,
+    options
+  );
+  return _resendRequestEmailsDeserialize(result);
+}
+function _resendEmailSend(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendEmail{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _resendEmailDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function resendEmail(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const result = await _resendEmailSend(context, resourceGroupName, certificateOrderName, options);
+  return _resendEmailDeserialize(result);
+}
+function _renewSend(context, resourceGroupName, certificateOrderName, renewCertificateOrderRequest, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/renew{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    body: (0, import_models.renewCertificateOrderRequestSerializer)(renewCertificateOrderRequest)
+  });
+}
+async function _renewDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function renew(context, resourceGroupName, certificateOrderName, renewCertificateOrderRequest, options = { requestOptions: {} }) {
+  const result = await _renewSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    renewCertificateOrderRequest,
+    options
+  );
+  return _renewDeserialize(result);
+}
+function _reissueSend(context, resourceGroupName, certificateOrderName, reissueCertificateOrderRequest, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/reissue{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    body: (0, import_models.reissueCertificateOrderRequestSerializer)(reissueCertificateOrderRequest)
+  });
+}
+async function _reissueDeserialize(result) {
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function reissue(context, resourceGroupName, certificateOrderName, reissueCertificateOrderRequest, options = { requestOptions: {} }) {
+  const result = await _reissueSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    reissueCertificateOrderRequest,
+    options
+  );
+  return _reissueDeserialize(result);
+}
+function _listSend(context, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/certificateOrders{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models._appServiceCertificateOrderCollectionDeserializer)(result.body);
+}
+function list(context, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listSend(context, options),
+    _listDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2024-11-01" }
+  );
+}
+function _listByResourceGroupSend(context, resourceGroupName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listByResourceGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models._appServiceCertificateOrderCollectionDeserializer)(result.body);
+}
+function listByResourceGroup(context, resourceGroupName, options = { requestOptions: {} }) {
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listByResourceGroupSend(context, resourceGroupName, options),
+    _listByResourceGroupDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2024-11-01" }
+  );
+}
+function _$deleteSend(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).delete({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
+}
+async function _$deleteDeserialize(result) {
+  const expectedStatuses = ["200", "204"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return;
+}
+async function $delete(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const result = await _$deleteSend(context, resourceGroupName, certificateOrderName, options);
+  return _$deleteDeserialize(result);
+}
+function _updateSend(context, resourceGroupName, certificateOrderName, certificateDistinguishedName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).patch({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: (0, import_models.appServiceCertificateOrderPatchResourceSerializer)(certificateDistinguishedName)
+  });
+}
+async function _updateDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateOrderDeserializer)(result.body);
+}
+async function update(context, resourceGroupName, certificateOrderName, certificateDistinguishedName, options = { requestOptions: {} }) {
+  const result = await _updateSend(
+    context,
+    resourceGroupName,
+    certificateOrderName,
+    certificateDistinguishedName,
+    options
+  );
+  return _updateDeserialize(result);
+}
+function _createOrUpdateSend(context, resourceGroupName, certificateOrderName, certificateDistinguishedName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).put({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: (0, import_models.appServiceCertificateOrderSerializer)(certificateDistinguishedName)
+  });
+}
+async function _createOrUpdateDeserialize(result) {
+  const expectedStatuses = ["200", "201", "202"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateOrderDeserializer)(result.body);
+}
+function createOrUpdate(context, resourceGroupName, certificateOrderName, certificateDistinguishedName, options = { requestOptions: {} }) {
+  return (0, import_pollingHelpers.getLongRunningPoller)(context, _createOrUpdateDeserialize, ["200", "201", "202"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _createOrUpdateSend(
+      context,
+      resourceGroupName,
+      certificateOrderName,
+      certificateDistinguishedName,
+      options
+    ),
+    resourceLocationConfig: "location",
+    apiVersion: context.apiVersion ?? "2024-11-01"
+  });
+}
+function _getSend(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      certificateOrderName,
+      "api%2Dversion": context.apiVersion ?? "2024-11-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = (0, import_core_client.createRestError)(result);
+    error.details = (0, import_models.defaultErrorResponseDeserializer)(result.body);
+    throw error;
+  }
+  return (0, import_models.appServiceCertificateOrderDeserializer)(result.body);
+}
+async function get(context, resourceGroupName, certificateOrderName, options = { requestOptions: {} }) {
+  const result = await _getSend(context, resourceGroupName, certificateOrderName, options);
+  return _getDeserialize(result);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $delete,
+  _$deleteDeserialize,
+  _$deleteSend,
+  _createOrUpdateCertificateDeserialize,
+  _createOrUpdateCertificateSend,
+  _createOrUpdateDeserialize,
+  _createOrUpdateSend,
+  _deleteCertificateDeserialize,
+  _deleteCertificateSend,
+  _getCertificateDeserialize,
+  _getCertificateSend,
+  _getDeserialize,
+  _getSend,
+  _listByResourceGroupDeserialize,
+  _listByResourceGroupSend,
+  _listCertificatesDeserialize,
+  _listCertificatesSend,
+  _listDeserialize,
+  _listSend,
+  _reissueDeserialize,
+  _reissueSend,
+  _renewDeserialize,
+  _renewSend,
+  _resendEmailDeserialize,
+  _resendEmailSend,
+  _resendRequestEmailsDeserialize,
+  _resendRequestEmailsSend,
+  _retrieveCertificateActionsDeserialize,
+  _retrieveCertificateActionsSend,
+  _retrieveCertificateEmailHistoryDeserialize,
+  _retrieveCertificateEmailHistorySend,
+  _retrieveSiteSealDeserialize,
+  _retrieveSiteSealSend,
+  _updateCertificateDeserialize,
+  _updateCertificateSend,
+  _updateDeserialize,
+  _updateSend,
+  _validatePurchaseInformationDeserialize,
+  _validatePurchaseInformationSend,
+  _verifyDomainOwnershipDeserialize,
+  _verifyDomainOwnershipSend,
+  createOrUpdate,
+  createOrUpdateCertificate,
+  deleteCertificate,
+  get,
+  getCertificate,
+  list,
+  listByResourceGroup,
+  listCertificates,
+  reissue,
+  renew,
+  resendEmail,
+  resendRequestEmails,
+  retrieveCertificateActions,
+  retrieveCertificateEmailHistory,
+  retrieveSiteSeal,
+  update,
+  updateCertificate,
+  validatePurchaseInformation,
+  verifyDomainOwnership
+});
+//# sourceMappingURL=operations.js.map