@azure/arm-storage 19.1.0 → 20.0.0

package/dist/browser/api/storageAccounts/operations.js

@@ -0,0 +1,544 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { errorResponseDeserializer, storageAccountCheckNameAvailabilityParametersSerializer, checkNameAvailabilityResultDeserializer, storageAccountDeserializer, blobRestoreStatusDeserializer, blobRestoreParametersSerializer, storageAccountCreateParametersSerializer, storageAccountUpdateParametersSerializer, _storageAccountListResultDeserializer, storageAccountListKeysResultDeserializer, storageAccountRegenerateKeyParametersSerializer, accountSasParametersSerializer, listAccountSasResponseDeserializer, serviceSasParametersSerializer, listServiceSasResponseDeserializer, storageAccountMigrationSerializer, storageAccountMigrationDeserializer, } from "../../models/models.js";
+import { buildPagedAsyncIterator } from "../../static-helpers/pagingHelpers.js";
+import { getLongRunningPoller } from "../../static-helpers/pollingHelpers.js";
+import { expandUrlTemplate } from "../../static-helpers/urlTemplate.js";
+import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
+export function _getCustomerInitiatedMigrationSend(context, resourceGroupName, accountName, migrationName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/accountMigrations/{migrationName}{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        migrationName: migrationName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _getCustomerInitiatedMigrationDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountMigrationDeserializer(result.body);
+}
+/** Gets the status of the ongoing migration for the specified storage account. */
+export async function getCustomerInitiatedMigration(context, resourceGroupName, accountName, migrationName, options = { requestOptions: {} }) {
+    const result = await _getCustomerInitiatedMigrationSend(context, resourceGroupName, accountName, migrationName, options);
+    return _getCustomerInitiatedMigrationDeserialize(result);
+}
+export function _revokeUserDelegationKeysSend(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/revokeUserDelegationKeys{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _revokeUserDelegationKeysDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** Revoke user delegation keys. */
+export async function revokeUserDelegationKeys(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const result = await _revokeUserDelegationKeysSend(context, resourceGroupName, accountName, options);
+    return _revokeUserDelegationKeysDeserialize(result);
+}
+export function _restoreBlobRangesSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/restoreBlobRanges{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: blobRestoreParametersSerializer(parameters),
+    });
+}
+export async function _restoreBlobRangesDeserialize(result) {
+    const expectedStatuses = ["200", "202", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return blobRestoreStatusDeserializer(result.body);
+}
+/** Restore blobs in the specified blob ranges */
+export function restoreBlobRanges(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _restoreBlobRangesDeserialize, ["200", "202", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _restoreBlobRangesSend(context, resourceGroupName, accountName, parameters, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _customerInitiatedMigrationSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/startAccountMigration{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        body: storageAccountMigrationSerializer(parameters),
+    });
+}
+export async function _customerInitiatedMigrationDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** Account Migration request can be triggered for a storage account to change its redundancy level. The migration updates the non-zonal redundant storage account to a zonal redundant account or vice-versa in order to have better reliability and availability. Zone-redundant storage (ZRS) replicates your storage account synchronously across three Azure availability zones in the primary region. */
+export function customerInitiatedMigration(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _customerInitiatedMigrationDeserialize, ["202", "200", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _customerInitiatedMigrationSend(context, resourceGroupName, accountName, parameters, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _abortHierarchicalNamespaceMigrationSend(context, resourceGroupName, accountName, options = {
+    requestOptions: {},
+}) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/aborthnsonmigration{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _abortHierarchicalNamespaceMigrationDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** Abort live Migration of storage account to enable Hns */
+export function abortHierarchicalNamespaceMigration(context, resourceGroupName, accountName, options = {
+    requestOptions: {},
+}) {
+    return getLongRunningPoller(context, _abortHierarchicalNamespaceMigrationDeserialize, ["202", "200", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _abortHierarchicalNamespaceMigrationSend(context, resourceGroupName, accountName, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _hierarchicalNamespaceMigrationSend(context, resourceGroupName, accountName, requestType, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/hnsonmigration{?api%2Dversion,requestType}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+        requestType: requestType,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _hierarchicalNamespaceMigrationDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** Live Migration of storage account to enable Hns */
+export function hierarchicalNamespaceMigration(context, resourceGroupName, accountName, requestType, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _hierarchicalNamespaceMigrationDeserialize, ["202", "200", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _hierarchicalNamespaceMigrationSend(context, resourceGroupName, accountName, requestType, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _failoverSend(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/failover{?api%2Dversion,failoverType}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+        failoverType: !options?.failoverType ? options?.failoverType : "Planned",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _failoverDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is only available while the primary and secondary endpoints are available. The primary use case of a Planned Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter to 'Planned'. Learn more about the failover options here- https://learn.microsoft.com/azure/storage/common/storage-disaster-recovery-guidance */
+export function failover(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _failoverDeserialize, ["202", "200", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _failoverSend(context, resourceGroupName, accountName, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _listServiceSASSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listServiceSas{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: serviceSasParametersSerializer(parameters),
+    });
+}
+export async function _listServiceSASDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return listServiceSasResponseDeserializer(result.body);
+}
+/** List service SAS credentials of a specific resource. */
+export async function listServiceSAS(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const result = await _listServiceSASSend(context, resourceGroupName, accountName, parameters, options);
+    return _listServiceSASDeserialize(result);
+}
+export function _listAccountSASSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listAccountSas{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: accountSasParametersSerializer(parameters),
+    });
+}
+export async function _listAccountSASDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return listAccountSasResponseDeserializer(result.body);
+}
+/** List SAS credentials of a storage account. */
+export async function listAccountSAS(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const result = await _listAccountSASSend(context, resourceGroupName, accountName, parameters, options);
+    return _listAccountSASDeserialize(result);
+}
+export function _regenerateKeySend(context, resourceGroupName, accountName, regenerateKeyParameter, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/regenerateKey{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: storageAccountRegenerateKeyParametersSerializer(regenerateKeyParameter),
+    });
+}
+export async function _regenerateKeyDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountListKeysResultDeserializer(result.body);
+}
+/** Regenerates one of the access keys or Kerberos keys for the specified storage account. */
+export async function regenerateKey(context, resourceGroupName, accountName, regenerateKeyParameter, options = { requestOptions: {} }) {
+    const result = await _regenerateKeySend(context, resourceGroupName, accountName, regenerateKeyParameter, options);
+    return _regenerateKeyDeserialize(result);
+}
+export function _listKeysSend(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listKeys{?api%2Dversion,%24expand}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+        "%24expand": !options?.expand ? options?.expand : "kerb",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _listKeysDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountListKeysResultDeserializer(result.body);
+}
+/** Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account. */
+export async function listKeys(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const result = await _listKeysSend(context, resourceGroupName, accountName, options);
+    return _listKeysDeserialize(result);
+}
+export function _listSend(context, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/storageAccounts{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _listDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return _storageAccountListResultDeserializer(result.body);
+}
+/** Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the ListKeys operation for this. */
+export function list(context, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSend(context, options), _listDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2025-08-01" });
+}
+export function _listByResourceGroupSend(context, resourceGroupName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _listByResourceGroupDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return _storageAccountListResultDeserializer(result.body);
+}
+/** Lists all the storage accounts available under the given resource group. Note that storage keys are not returned; use the ListKeys operation for this. */
+export function listByResourceGroup(context, resourceGroupName, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listByResourceGroupSend(context, resourceGroupName, options), _listByResourceGroupDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2025-08-01" });
+}
+export function _$deleteSend(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _$deleteDeserialize(result) {
+    const expectedStatuses = ["200", "204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return;
+}
+/** Deletes a storage account in Microsoft Azure. */
+export async function $delete(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const result = await _$deleteSend(context, resourceGroupName, accountName, options);
+    return _$deleteDeserialize(result);
+}
+export function _updateSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).patch({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: storageAccountUpdateParametersSerializer(parameters),
+    });
+}
+export async function _updateDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountDeserializer(result.body);
+}
+/** The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It can also be used to map the account to a custom domain. Only one custom domain is supported per storage account; the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This call does not change the storage keys for the account. If you want to change the storage account keys, use the regenerate keys operation. The location and name of the storage account cannot be changed after creation. */
+export async function update(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const result = await _updateSend(context, resourceGroupName, accountName, parameters, options);
+    return _updateDeserialize(result);
+}
+export function _createSend(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).put({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: storageAccountCreateParametersSerializer(parameters),
+    });
+}
+export async function _createDeserialize(result) {
+    const expectedStatuses = ["200", "202", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountDeserializer(result.body);
+}
+/** Asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed. */
+export function create(context, resourceGroupName, accountName, parameters, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _createDeserialize, ["200", "202", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _createSend(context, resourceGroupName, accountName, parameters, options),
+        resourceLocationConfig: "location",
+        apiVersion: context.apiVersion ?? "2025-08-01",
+    });
+}
+export function _getPropertiesSend(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}{?api%2Dversion,%24expand}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: resourceGroupName,
+        accountName: accountName,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+        "%24expand": options?.expand,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _getPropertiesDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return storageAccountDeserializer(result.body);
+}
+/** Returns the properties for the specified storage account including but not limited to name, SKU name, location, and account status. The ListKeys operation should be used to retrieve storage keys. */
+export async function getProperties(context, resourceGroupName, accountName, options = { requestOptions: {} }) {
+    const result = await _getPropertiesSend(context, resourceGroupName, accountName, options);
+    return _getPropertiesDeserialize(result);
+}
+export function _checkNameAvailabilitySend(context, accountName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        "api%2Dversion": context.apiVersion ?? "2025-08-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: storageAccountCheckNameAvailabilityParametersSerializer(accountName),
+    });
+}
+export async function _checkNameAvailabilityDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = errorResponseDeserializer(result.body);
+        throw error;
+    }
+    return checkNameAvailabilityResultDeserializer(result.body);
+}
+/** Checks that the storage account name is valid and is not already in use. */
+export async function checkNameAvailability(context, accountName, options = { requestOptions: {} }) {
+    const result = await _checkNameAvailabilitySend(context, accountName, options);
+    return _checkNameAvailabilityDeserialize(result);
+}
+//# sourceMappingURL=operations.js.map