@azure/keyvault-certificates
Version:
Azure Key Vault Certificates
1,113 lines (1,112 loc) • 44 kB
JavaScript
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, {
_backupCertificateDeserialize: () => _backupCertificateDeserialize,
_backupCertificateSend: () => _backupCertificateSend,
_createCertificateDeserialize: () => _createCertificateDeserialize,
_createCertificateSend: () => _createCertificateSend,
_deleteCertificateContactsDeserialize: () => _deleteCertificateContactsDeserialize,
_deleteCertificateContactsSend: () => _deleteCertificateContactsSend,
_deleteCertificateDeserialize: () => _deleteCertificateDeserialize,
_deleteCertificateIssuerDeserialize: () => _deleteCertificateIssuerDeserialize,
_deleteCertificateIssuerSend: () => _deleteCertificateIssuerSend,
_deleteCertificateOperationDeserialize: () => _deleteCertificateOperationDeserialize,
_deleteCertificateOperationSend: () => _deleteCertificateOperationSend,
_deleteCertificateSend: () => _deleteCertificateSend,
_getCertificateContactsDeserialize: () => _getCertificateContactsDeserialize,
_getCertificateContactsSend: () => _getCertificateContactsSend,
_getCertificateDeserialize: () => _getCertificateDeserialize,
_getCertificateIssuerDeserialize: () => _getCertificateIssuerDeserialize,
_getCertificateIssuerSend: () => _getCertificateIssuerSend,
_getCertificateIssuersDeserialize: () => _getCertificateIssuersDeserialize,
_getCertificateIssuersSend: () => _getCertificateIssuersSend,
_getCertificateOperationDeserialize: () => _getCertificateOperationDeserialize,
_getCertificateOperationSend: () => _getCertificateOperationSend,
_getCertificatePolicyDeserialize: () => _getCertificatePolicyDeserialize,
_getCertificatePolicySend: () => _getCertificatePolicySend,
_getCertificateSend: () => _getCertificateSend,
_getCertificateVersionsDeserialize: () => _getCertificateVersionsDeserialize,
_getCertificateVersionsSend: () => _getCertificateVersionsSend,
_getCertificatesDeserialize: () => _getCertificatesDeserialize,
_getCertificatesSend: () => _getCertificatesSend,
_getDeletedCertificateDeserialize: () => _getDeletedCertificateDeserialize,
_getDeletedCertificateSend: () => _getDeletedCertificateSend,
_getDeletedCertificatesDeserialize: () => _getDeletedCertificatesDeserialize,
_getDeletedCertificatesSend: () => _getDeletedCertificatesSend,
_importCertificateDeserialize: () => _importCertificateDeserialize,
_importCertificateSend: () => _importCertificateSend,
_mergeCertificateDeserialize: () => _mergeCertificateDeserialize,
_mergeCertificateSend: () => _mergeCertificateSend,
_purgeDeletedCertificateDeserialize: () => _purgeDeletedCertificateDeserialize,
_purgeDeletedCertificateSend: () => _purgeDeletedCertificateSend,
_recoverDeletedCertificateDeserialize: () => _recoverDeletedCertificateDeserialize,
_recoverDeletedCertificateSend: () => _recoverDeletedCertificateSend,
_restoreCertificateDeserialize: () => _restoreCertificateDeserialize,
_restoreCertificateSend: () => _restoreCertificateSend,
_setCertificateContactsDeserialize: () => _setCertificateContactsDeserialize,
_setCertificateContactsSend: () => _setCertificateContactsSend,
_setCertificateIssuerDeserialize: () => _setCertificateIssuerDeserialize,
_setCertificateIssuerSend: () => _setCertificateIssuerSend,
_updateCertificateDeserialize: () => _updateCertificateDeserialize,
_updateCertificateIssuerDeserialize: () => _updateCertificateIssuerDeserialize,
_updateCertificateIssuerSend: () => _updateCertificateIssuerSend,
_updateCertificateOperationDeserialize: () => _updateCertificateOperationDeserialize,
_updateCertificateOperationSend: () => _updateCertificateOperationSend,
_updateCertificatePolicyDeserialize: () => _updateCertificatePolicyDeserialize,
_updateCertificatePolicySend: () => _updateCertificatePolicySend,
_updateCertificateSend: () => _updateCertificateSend,
backupCertificate: () => backupCertificate,
createCertificate: () => createCertificate,
deleteCertificate: () => deleteCertificate,
deleteCertificateContacts: () => deleteCertificateContacts,
deleteCertificateIssuer: () => deleteCertificateIssuer,
deleteCertificateOperation: () => deleteCertificateOperation,
getCertificate: () => getCertificate,
getCertificateContacts: () => getCertificateContacts,
getCertificateIssuer: () => getCertificateIssuer,
getCertificateIssuers: () => getCertificateIssuers,
getCertificateOperation: () => getCertificateOperation,
getCertificatePolicy: () => getCertificatePolicy,
getCertificateVersions: () => getCertificateVersions,
getCertificates: () => getCertificates,
getDeletedCertificate: () => getDeletedCertificate,
getDeletedCertificates: () => getDeletedCertificates,
importCertificate: () => importCertificate,
mergeCertificate: () => mergeCertificate,
purgeDeletedCertificate: () => purgeDeletedCertificate,
recoverDeletedCertificate: () => recoverDeletedCertificate,
restoreCertificate: () => restoreCertificate,
setCertificateContacts: () => setCertificateContacts,
setCertificateIssuer: () => setCertificateIssuer,
updateCertificate: () => updateCertificate,
updateCertificateIssuer: () => updateCertificateIssuer,
updateCertificateOperation: () => updateCertificateOperation,
updateCertificatePolicy: () => updateCertificatePolicy
});
module.exports = __toCommonJS(operations_exports);
var import_models = require("../models/models.js");
var import_pagingHelpers = require("../static-helpers/pagingHelpers.js");
var import_urlTemplate = require("../static-helpers/urlTemplate.js");
var import_core_client = require("@azure-rest/core-client");
function _recoverDeletedCertificateSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/deletedcertificates/{certificate-name}/recover{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).post({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _recoverDeletedCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function recoverDeletedCertificate(context, certificateName, options = { requestOptions: {} }) {
const result = await _recoverDeletedCertificateSend(context, certificateName, options);
return _recoverDeletedCertificateDeserialize(result);
}
function _purgeDeletedCertificateSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/deletedcertificates/{certificate-name}{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).delete({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _purgeDeletedCertificateDeserialize(result) {
const expectedStatuses = ["204"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return;
}
async function purgeDeletedCertificate(context, certificateName, options = { requestOptions: {} }) {
const result = await _purgeDeletedCertificateSend(context, certificateName, options);
return _purgeDeletedCertificateDeserialize(result);
}
function _getDeletedCertificateSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/deletedcertificates/{certificate-name}{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getDeletedCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.deletedCertificateBundleDeserializer)(result.body);
}
async function getDeletedCertificate(context, certificateName, options = { requestOptions: {} }) {
const result = await _getDeletedCertificateSend(context, certificateName, options);
return _getDeletedCertificateDeserialize(result);
}
function _getDeletedCertificatesSend(context, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/deletedcertificates{?api%2Dversion,maxresults,includePending}",
{
"api%2Dversion": context.apiVersion,
maxresults: options?.maxresults,
includePending: options?.includePending
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getDeletedCertificatesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models._deletedCertificateListResultDeserializer)(result.body);
}
function getDeletedCertificates(context, options = { requestOptions: {} }) {
return (0, import_pagingHelpers.buildPagedAsyncIterator)(
context,
() => _getDeletedCertificatesSend(context, options),
_getDeletedCertificatesDeserialize,
["200"],
{ itemName: "value", nextLinkName: "nextLink" }
);
}
function _restoreCertificateSend(context, parameters, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/restore{?api%2Dversion}",
{
"api%2Dversion": context.apiVersion
},
{
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.certificateRestoreParametersSerializer)(parameters)
});
}
async function _restoreCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function restoreCertificate(context, parameters, options = { requestOptions: {} }) {
const result = await _restoreCertificateSend(context, parameters, options);
return _restoreCertificateDeserialize(result);
}
function _backupCertificateSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/backup{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).post({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _backupCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.backupCertificateResultDeserializer)(result.body);
}
async function backupCertificate(context, certificateName, options = { requestOptions: {} }) {
const result = await _backupCertificateSend(context, certificateName, options);
return _backupCertificateDeserialize(result);
}
function _mergeCertificateSend(context, certificateName, parameters, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/pending/merge{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
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.certificateMergeParametersSerializer)(parameters)
});
}
async function _mergeCertificateDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function mergeCertificate(context, certificateName, parameters, options = { requestOptions: {} }) {
const result = await _mergeCertificateSend(context, certificateName, parameters, options);
return _mergeCertificateDeserialize(result);
}
function _deleteCertificateOperationSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/pending{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).delete({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _deleteCertificateOperationDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateOperationDeserializer)(result.body);
}
async function deleteCertificateOperation(context, certificateName, options = { requestOptions: {} }) {
const result = await _deleteCertificateOperationSend(context, certificateName, options);
return _deleteCertificateOperationDeserialize(result);
}
function _getCertificateOperationSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/pending{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificateOperationDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateOperationDeserializer)(result.body);
}
async function getCertificateOperation(context, certificateName, options = { requestOptions: {} }) {
const result = await _getCertificateOperationSend(context, certificateName, options);
return _getCertificateOperationDeserialize(result);
}
function _updateCertificateOperationSend(context, certificateName, certificateOperation, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/pending{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
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.certificateOperationUpdateParameterSerializer)(certificateOperation)
});
}
async function _updateCertificateOperationDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateOperationDeserializer)(result.body);
}
async function updateCertificateOperation(context, certificateName, certificateOperation, options = { requestOptions: {} }) {
const result = await _updateCertificateOperationSend(
context,
certificateName,
certificateOperation,
options
);
return _updateCertificateOperationDeserialize(result);
}
function _getCertificateSend(context, certificateName, certificateVersion, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/{certificate-version}{?api%2Dversion}",
{
"certificate-name": certificateName,
"certificate-version": certificateVersion,
"api%2Dversion": context.apiVersion
},
{
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.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function getCertificate(context, certificateName, certificateVersion, options = { requestOptions: {} }) {
const result = await _getCertificateSend(context, certificateName, certificateVersion, options);
return _getCertificateDeserialize(result);
}
function _updateCertificateSend(context, certificateName, certificateVersion, parameters, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/{certificate-version}{?api%2Dversion}",
{
"certificate-name": certificateName,
"certificate-version": certificateVersion,
"api%2Dversion": context.apiVersion
},
{
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.certificateUpdateParametersSerializer)(parameters)
});
}
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.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function updateCertificate(context, certificateName, certificateVersion, parameters, options = { requestOptions: {} }) {
const result = await _updateCertificateSend(
context,
certificateName,
certificateVersion,
parameters,
options
);
return _updateCertificateDeserialize(result);
}
function _updateCertificatePolicySend(context, certificateName, certificatePolicy, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/policy{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
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.certificatePolicySerializer)(certificatePolicy)
});
}
async function _updateCertificatePolicyDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificatePolicyDeserializer)(result.body);
}
async function updateCertificatePolicy(context, certificateName, certificatePolicy, options = { requestOptions: {} }) {
const result = await _updateCertificatePolicySend(
context,
certificateName,
certificatePolicy,
options
);
return _updateCertificatePolicyDeserialize(result);
}
function _getCertificatePolicySend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/policy{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificatePolicyDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificatePolicyDeserializer)(result.body);
}
async function getCertificatePolicy(context, certificateName, options = { requestOptions: {} }) {
const result = await _getCertificatePolicySend(context, certificateName, options);
return _getCertificatePolicyDeserialize(result);
}
function _getCertificateVersionsSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/versions{?api%2Dversion,maxresults}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion,
maxresults: options?.maxresults
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificateVersionsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models._certificateListResultDeserializer)(result.body);
}
function getCertificateVersions(context, certificateName, options = { requestOptions: {} }) {
return (0, import_pagingHelpers.buildPagedAsyncIterator)(
context,
() => _getCertificateVersionsSend(context, certificateName, options),
_getCertificateVersionsDeserialize,
["200"],
{ itemName: "value", nextLinkName: "nextLink" }
);
}
function _importCertificateSend(context, certificateName, parameters, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/import{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
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.certificateImportParametersSerializer)(parameters)
});
}
async function _importCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateBundleDeserializer)(result.body);
}
async function importCertificate(context, certificateName, parameters, options = { requestOptions: {} }) {
const result = await _importCertificateSend(context, certificateName, parameters, options);
return _importCertificateDeserialize(result);
}
function _createCertificateSend(context, certificateName, parameters, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}/create{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
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.certificateCreateParametersSerializer)(parameters)
});
}
async function _createCertificateDeserialize(result) {
const expectedStatuses = ["202"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.certificateOperationDeserializer)(result.body);
}
async function createCertificate(context, certificateName, parameters, options = { requestOptions: {} }) {
const result = await _createCertificateSend(context, certificateName, parameters, options);
return _createCertificateDeserialize(result);
}
function _deleteCertificateIssuerSend(context, issuerName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/issuers/{issuer-name}{?api%2Dversion}",
{
"issuer-name": issuerName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).delete({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _deleteCertificateIssuerDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.issuerBundleDeserializer)(result.body);
}
async function deleteCertificateIssuer(context, issuerName, options = { requestOptions: {} }) {
const result = await _deleteCertificateIssuerSend(context, issuerName, options);
return _deleteCertificateIssuerDeserialize(result);
}
function _getCertificateIssuerSend(context, issuerName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/issuers/{issuer-name}{?api%2Dversion}",
{
"issuer-name": issuerName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificateIssuerDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.issuerBundleDeserializer)(result.body);
}
async function getCertificateIssuer(context, issuerName, options = { requestOptions: {} }) {
const result = await _getCertificateIssuerSend(context, issuerName, options);
return _getCertificateIssuerDeserialize(result);
}
function _updateCertificateIssuerSend(context, issuerName, parameter, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/issuers/{issuer-name}{?api%2Dversion}",
{
"issuer-name": issuerName,
"api%2Dversion": context.apiVersion
},
{
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.certificateIssuerUpdateParametersSerializer)(parameter)
});
}
async function _updateCertificateIssuerDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.issuerBundleDeserializer)(result.body);
}
async function updateCertificateIssuer(context, issuerName, parameter, options = { requestOptions: {} }) {
const result = await _updateCertificateIssuerSend(context, issuerName, parameter, options);
return _updateCertificateIssuerDeserialize(result);
}
function _setCertificateIssuerSend(context, issuerName, parameter, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/issuers/{issuer-name}{?api%2Dversion}",
{
"issuer-name": issuerName,
"api%2Dversion": context.apiVersion
},
{
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.certificateIssuerSetParametersSerializer)(parameter)
});
}
async function _setCertificateIssuerDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.issuerBundleDeserializer)(result.body);
}
async function setCertificateIssuer(context, issuerName, parameter, options = { requestOptions: {} }) {
const result = await _setCertificateIssuerSend(context, issuerName, parameter, options);
return _setCertificateIssuerDeserialize(result);
}
function _getCertificateIssuersSend(context, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/issuers{?api%2Dversion,maxresults}",
{
"api%2Dversion": context.apiVersion,
maxresults: options?.maxresults
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificateIssuersDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models._certificateIssuerListResultDeserializer)(result.body);
}
function getCertificateIssuers(context, options = { requestOptions: {} }) {
return (0, import_pagingHelpers.buildPagedAsyncIterator)(
context,
() => _getCertificateIssuersSend(context, options),
_getCertificateIssuersDeserialize,
["200"],
{ itemName: "value", nextLinkName: "nextLink" }
);
}
function _deleteCertificateContactsSend(context, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/contacts{?api%2Dversion}",
{
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).delete({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _deleteCertificateContactsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.contactsDeserializer)(result.body);
}
async function deleteCertificateContacts(context, options = { requestOptions: {} }) {
const result = await _deleteCertificateContactsSend(context, options);
return _deleteCertificateContactsDeserialize(result);
}
function _getCertificateContactsSend(context, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/contacts{?api%2Dversion}",
{
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificateContactsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.contactsDeserializer)(result.body);
}
async function getCertificateContacts(context, options = { requestOptions: {} }) {
const result = await _getCertificateContactsSend(context, options);
return _getCertificateContactsDeserialize(result);
}
function _setCertificateContactsSend(context, contacts, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/contacts{?api%2Dversion}",
{
"api%2Dversion": context.apiVersion
},
{
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.contactsSerializer)(contacts)
});
}
async function _setCertificateContactsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.contactsDeserializer)(result.body);
}
async function setCertificateContacts(context, contacts, options = { requestOptions: {} }) {
const result = await _setCertificateContactsSend(context, contacts, options);
return _setCertificateContactsDeserialize(result);
}
function _deleteCertificateSend(context, certificateName, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates/{certificate-name}{?api%2Dversion}",
{
"certificate-name": certificateName,
"api%2Dversion": context.apiVersion
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).delete({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _deleteCertificateDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models.deletedCertificateBundleDeserializer)(result.body);
}
async function deleteCertificate(context, certificateName, options = { requestOptions: {} }) {
const result = await _deleteCertificateSend(context, certificateName, options);
return _deleteCertificateDeserialize(result);
}
function _getCertificatesSend(context, options = { requestOptions: {} }) {
const path = (0, import_urlTemplate.expandUrlTemplate)(
"/certificates{?api%2Dversion,maxresults,includePending}",
{
"api%2Dversion": context.apiVersion,
maxresults: options?.maxresults,
includePending: options?.includePending
},
{
allowReserved: options?.requestOptions?.skipUrlEncoding
}
);
return context.path(path).get({
...(0, import_core_client.operationOptionsToRequestParameters)(options),
headers: {
accept: "application/json",
...options.requestOptions?.headers
}
});
}
async function _getCertificatesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = (0, import_core_client.createRestError)(result);
error.details = (0, import_models.keyVaultErrorDeserializer)(result.body);
throw error;
}
return (0, import_models._certificateListResultDeserializer)(result.body);
}
function getCertificates(context, options = { requestOptions: {} }) {
return (0, import_pagingHelpers.buildPagedAsyncIterator)(
context,
() => _getCertificatesSend(context, options),
_getCertificatesDeserialize,
["200"],
{ itemName: "value", nextLinkName: "nextLink" }
);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
_backupCertificateDeserialize,
_backupCertificateSend,
_createCertificateDeserialize,
_createCertificateSend,
_deleteCertificateContactsDeserialize,
_deleteCertificateContactsSend,
_deleteCertificateDeserialize,
_deleteCertificateIssuerDeserialize,
_deleteCertificateIssuerSend,
_deleteCertificateOperationDeserialize,
_deleteCertificateOperationSend,
_deleteCertificateSend,
_getCertificateContactsDeserialize,
_getCertificateContactsSend,
_getCertificateDeserialize,
_getCertificateIssuerDeserialize,
_getCertificateIssuerSend,
_getCertificateIssuersDeserialize,
_getCertificateIssuersSend,
_getCertificateOperationDeserialize,
_getCertificateOperationSend,
_getCertificatePolicyDeserialize,
_getCertificatePolicySend,
_getCertificateSend,
_getCertificateVersionsDeserialize,
_getCertificateVersionsSend,
_getCertificatesDeserialize,
_getCertificatesSend,
_getDeletedCertificateDeserialize,
_getDeletedCertificateSend,
_getDeletedCertificatesDeserialize,
_getDeletedCertificatesSend,
_importCertificateDeserialize,
_importCertificateSend,
_mergeCertificateDeserialize,
_mergeCertificateSend,
_purgeDeletedCertificateDeserialize,
_purgeDeletedCertificateSend,
_recoverDeletedCertificateDeserialize,
_recoverDeletedCertificateSend,
_restoreCertificateDeserialize,
_restoreCertificateSend,
_setCertificateContactsDeserialize,
_setCertificateContactsSend,
_setCertificateIssuerDeserialize,
_setCertificateIssuerSend,
_updateCertificateDeserialize,
_updateCertificateIssuerDeserialize,
_updateCertificateIssuerSend,
_updateCertificateOperationDeserialize,
_updateCertificateOperationSend,
_updateCertificatePolicyDeserialize,
_updateCertificatePolicySend,
_updateCertificateSend,
backupCertificate,
createCertificate,
deleteCertificate,
deleteCertificateContacts,
deleteCertificateIssuer,
deleteCertificateOperation,
getCertificate,
getCertificateContacts,
getCertificateIssuer,
getCertificateIssuers,
getCertificateOperation,
getCertificatePolicy,
getCertificateVersions,
getCertificates,
getDeletedCertificate,
getDeletedCertificates,
importCertificate,
mergeCertificate,
purgeDeletedCertificate,
recoverDeletedCertificate,
restoreCertificate,
setCertificateContacts,
setCertificateIssuer,
updateCertificate,
updateCertificateIssuer,
updateCertificateOperation,
updateCertificatePolicy
});
//# sourceMappingURL=operations.js.map