@azure/keyvault-admin 4.6.1-alpha.20250225.1 → 4.7.0-alpha.20250227.1

package/dist/commonjs/lro/shim.js.map

@@ -1 +1 @@
-{"version":3,"file":"shim.js","sourceRoot":"","sources":["../../../src/lro/shim.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AA6DlC,gCA0EC;AA1EM,KAAK,UAAU,UAAU,CAC9B,UAA2C;;IAE3C,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;IAC9C,MAAM,YAAY,GAAgC;QAChD,MAAM;YACJ,OAAO,UAAU,CAAC,MAAM,CAAC;QAC3B,CAAC;QACD,SAAS;YACP,OAAO,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC;QACxC,CAAC;QACD,iBAAiB;YACf,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC/B,MAAM,IAAI,KAAK,CACb,4IAA4I,CAC7I,CAAC;YACJ,CAAC;YACD,MAAM,WAAW,iDACZ,UAAU,CAAC,cAAc,GACzB,UAAU,CAAC,cAAc,CAAC,MAAM,KACnC,SAAS,EAAE,UAAU,CAAC,cAAc,CAAC,MAAM,KAAK,YAAY,EAC5D,WAAW,EACT,UAAU,CAAC,cAAc,CAAC,MAAM,KAAK,WAAW;oBAChD,UAAU,CAAC,cAAc,CAAC,MAAM,KAAK,QAAQ;oBAC7C,UAAU,CAAC,cAAc,CAAC,MAAM,KAAK,UAAU,GAClD,CAAC;YACF,IAAI,WAAW,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC/B,WAAW,CAAC,KAAK,GAAG,SAAS,CAAC;YAChC,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,SAAS;YACP,OAAO,UAAU,CAAC,MAAM,CAAC;QAC3B,CAAC;QACD,QAAQ;YACN,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC/B,MAAM,IAAI,KAAK,CACb,4IAA4I,CAC7I,CAAC;YACJ,CAAC;YACD,OAAO,IAAI,CAAC,SAAS,CAAC;gBACpB,KAAK,EAAE,UAAU,CAAC,cAAc;aACjC,CAAC,CAAC;QACL,CAAC;QACD,WAAW;YACT,eAAe,CAAC,KAAK,EAAE,CAAC;QAC1B,CAAC;QACD,UAAU,EAAE,UAAU,CAAC,UAAU;QACjC,KAAK,CAAC,IAAI,CAAC,OAAO;YAChB,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC;QACD,aAAa,CAAC,WAA+C;YAC3D,SAAS,aAAa;gBACpB,eAAe,CAAC,KAAK,EAAE,CAAC;YAC1B,CAAC;YACD,MAAM,gBAAgB,GAAG,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,WAAW,CAAC;YAClD,MAAM,WAAW,GAAG,eAAe,CAAC,MAAM,CAAC;YAC3C,IAAI,gBAAgB,aAAhB,gBAAgB,uBAAhB,gBAAgB,CAAE,OAAO,EAAE,CAAC;gBAC9B,eAAe,CAAC,KAAK,EAAE,CAAC;YAC1B,CAAC;iBAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;gBAChC,gBAAgB,aAAhB,gBAAgB,uBAAhB,gBAAgB,CAAE,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE;oBACzD,IAAI,EAAE,IAAI;iBACX,CAAC,CAAC;YACL,CAAC;YACD,OAAO,UAAU,CAAC,aAAa,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;QAC3E,CAAC;KACF,CAAC;IACF,MAAM,UAAU,CAAC,SAAS,EAAE,CAAC;IAC7B,8DAA8D;IAC9D,wEAAwE;IACxE,IAAI,MAAA,MAAC,UAAU,CAAC,cAAsB,0CAAE,MAAM,0CAAE,gBAAgB,EAAE,CAAC;QAChE,UAAU,CAAC,cAAsB,CAAC,MAAM,CAAC,gBAAgB,GAAG,SAAS,CAAC;IACzE,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { AbortSignalLike } from \"@azure/abort-controller\";\nimport type {\n  CancelOnProgress,\n  OperationState,\n  PollerLike as CorePollerLike,\n} from \"@azure/core-lro\";\nimport type { KeyVaultAdminPollOperationState } from \"./models.js\";\n\n/**\n * A simple poller that can be used to poll a long running operation.\n */\nexport interface PollerLike<TState extends KeyVaultAdminPollOperationState<TResult>, TResult> {\n  /**\n   * Returns true if the poller has finished polling.\n   */\n  isDone(): boolean;\n  /**\n   * Returns true if the poller is stopped.\n   */\n  isStopped(): boolean;\n  /**\n   * Returns the state of the operation.\n   */\n  getOperationState(): TState;\n  /**\n   * Returns the result value of the operation,\n   * regardless of the state of the poller.\n   * It can return undefined or an incomplete form of the final TResult value\n   * depending on the implementation.\n   */\n  getResult(): TResult | undefined;\n  /**\n   * Returns a promise that will resolve once a single polling request finishes.\n   * It does this by calling the update method of the Poller's operation.\n   */\n  poll(options?: { abortSignal?: AbortSignalLike }): Promise<void>;\n  /**\n   * Returns a promise that will resolve once the underlying operation is completed.\n   */\n  pollUntilDone(pollOptions?: { abortSignal?: AbortSignalLike }): Promise<TResult>;\n  /**\n   * Invokes the provided callback after each polling is completed,\n   * sending the current state of the poller's operation.\n   *\n   * It returns a method that can be used to stop receiving updates on the given callback function.\n   */\n  onProgress(callback: (state: TState) => void): CancelOnProgress;\n\n  /**\n   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.\n   */\n  toString(): string;\n\n  /**\n   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling\n   */\n  stopPolling(): void;\n}\n\nexport async function wrapPoller<TState extends OperationState<TResult>, TResult>(\n  httpPoller: CorePollerLike<TState, TResult>,\n): Promise<PollerLike<TState, TResult>> {\n  const abortController = new AbortController();\n  const simplePoller: PollerLike<TState, TResult> = {\n    isDone() {\n      return httpPoller.isDone;\n    },\n    isStopped() {\n      return abortController.signal.aborted;\n    },\n    getOperationState() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\",\n        );\n      }\n      const mergedState = {\n        ...httpPoller.operationState,\n        ...httpPoller.operationState.result,\n        isStarted: httpPoller.operationState.status !== \"notStarted\", // Shim for isStarted\n        isCompleted:\n          httpPoller.operationState.status === \"succeeded\" ||\n          httpPoller.operationState.status === \"failed\" ||\n          httpPoller.operationState.status === \"canceled\",\n      };\n      if (mergedState.error === null) {\n        mergedState.error = undefined;\n      }\n      return mergedState;\n    },\n    getResult() {\n      return httpPoller.result;\n    },\n    toString() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\",\n        );\n      }\n      return JSON.stringify({\n        state: httpPoller.operationState,\n      });\n    },\n    stopPolling() {\n      abortController.abort();\n    },\n    onProgress: httpPoller.onProgress,\n    async poll(options) {\n      httpPoller.poll(options);\n    },\n    pollUntilDone(pollOptions?: { abortSignal?: AbortSignalLike }) {\n      function abortListener(): void {\n        abortController.abort();\n      }\n      const inputAbortSignal = pollOptions?.abortSignal;\n      const abortSignal = abortController.signal;\n      if (inputAbortSignal?.aborted) {\n        abortController.abort();\n      } else if (!abortSignal.aborted) {\n        inputAbortSignal?.addEventListener(\"abort\", abortListener, {\n          once: true,\n        });\n      }\n      return httpPoller.pollUntilDone({ abortSignal: abortController.signal });\n    },\n  };\n  await httpPoller.submitted();\n  // clean up the final GET path so that we could skip final GET\n  // Workaround for https://github.com/Azure/azure-sdk-for-js/issues/32142\n  if ((httpPoller.operationState as any)?.config?.resourceLocation) {\n    (httpPoller.operationState as any).config.resourceLocation = undefined;\n  }\n  return simplePoller;\n}\n"]}
+{"version":3,"file":"shim.js","sourceRoot":"","sources":["../../../src/lro/shim.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { AbortSignalLike } from \"@azure/abort-controller\";\nimport type {\n  CancelOnProgress,\n  OperationState,\n  PollerLike as CorePollerLike,\n} from \"@azure/core-lro\";\nimport type { KeyVaultAdminPollOperationState } from \"./models.js\";\nimport { FullBackupOperation, RestoreOperation } from \"../generated/index.js\";\n\n/**\n * A simple poller that can be used to poll a long running operation.\n */\nexport interface PollerLike<TState extends KeyVaultAdminPollOperationState<TResult>, TResult> {\n  /**\n   * Returns true if the poller has finished polling.\n   */\n  isDone(): boolean;\n  /**\n   * Returns true if the poller is stopped.\n   */\n  isStopped(): boolean;\n  /**\n   * Returns the state of the operation.\n   */\n  getOperationState(): TState;\n  /**\n   * Returns the result value of the operation,\n   * regardless of the state of the poller.\n   * It can return undefined or an incomplete form of the final TResult value\n   * depending on the implementation.\n   */\n  getResult(): TResult | undefined;\n  /**\n   * Returns a promise that will resolve once a single polling request finishes.\n   * It does this by calling the update method of the Poller's operation.\n   */\n  poll(options?: { abortSignal?: AbortSignalLike }): Promise<void>;\n  /**\n   * Returns a promise that will resolve once the underlying operation is completed.\n   */\n  pollUntilDone(pollOptions?: { abortSignal?: AbortSignalLike }): Promise<TResult>;\n  /**\n   * Invokes the provided callback after each polling is completed,\n   * sending the current state of the poller's operation.\n   *\n   * It returns a method that can be used to stop receiving updates on the given callback function.\n   */\n  onProgress(callback: (state: TState) => void): CancelOnProgress;\n\n  /**\n   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.\n   */\n  toString(): string;\n\n  /**\n   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling\n   */\n  stopPolling(): void;\n}\n\nexport async function wrapPoller<TState extends OperationState<TResult>, TResult>(\n  httpPoller: CorePollerLike<TState, TResult>,\n): Promise<PollerLike<TState, TResult>> {\n  const abortController = new AbortController();\n  const simplePoller: PollerLike<TState, TResult> = {\n    isDone() {\n      return httpPoller.isDone;\n    },\n    isStopped() {\n      return abortController.signal.aborted;\n    },\n    getOperationState() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\",\n        );\n      }\n      const mergedState = {\n        ...httpPoller.operationState,\n        ...httpPoller.operationState.result,\n        isStarted: httpPoller.operationState.status !== \"notStarted\", // Shim for isStarted\n        isCompleted:\n          httpPoller.operationState.status === \"succeeded\" ||\n          httpPoller.operationState.status === \"failed\" ||\n          httpPoller.operationState.status === \"canceled\",\n      };\n      if (mergedState.error === null) {\n        mergedState.error = undefined;\n      }\n      return mergedState;\n    },\n    getResult() {\n      return httpPoller.result;\n    },\n    toString() {\n      if (!httpPoller.operationState) {\n        throw new Error(\n          \"Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState().\",\n        );\n      }\n      return JSON.stringify({\n        state: httpPoller.operationState,\n      });\n    },\n    stopPolling() {\n      abortController.abort();\n    },\n    onProgress: httpPoller.onProgress,\n    async poll(options) {\n      await httpPoller.poll(options);\n    },\n    pollUntilDone(pollOptions?: { abortSignal?: AbortSignalLike }) {\n      function abortListener(): void {\n        abortController.abort();\n      }\n      const inputAbortSignal = pollOptions?.abortSignal;\n      const abortSignal = abortController.signal;\n      if (inputAbortSignal?.aborted) {\n        abortController.abort();\n      } else if (!abortSignal.aborted) {\n        inputAbortSignal?.addEventListener(\"abort\", abortListener, {\n          once: true,\n        });\n      }\n      return httpPoller.pollUntilDone({ abortSignal: abortController.signal });\n    },\n  };\n  await httpPoller.submitted();\n  // clean up the final GET path so that we could skip final GET\n  // Workaround for https://github.com/Azure/azure-sdk-for-js/issues/32142\n  if ((httpPoller.operationState as any)?.config?.resourceLocation) {\n    (httpPoller.operationState as any).config.resourceLocation = undefined;\n  }\n  return simplePoller;\n}\n\n/**\n * A helper that standardizes the shape of the result of a long-running operation.\n *\n * smoothing over the differences between `null` and `undefined` sent over the wire in responses.\n */\nexport function updateState(state: OperationState<RestoreOperation | FullBackupOperation>): void {\n  if (state.result) {\n    state.result = {\n      ...state.result,\n      endTime: state.result.endTime ?? undefined,\n      startTime: state.result.startTime ?? undefined,\n      error: state.result.error ?? undefined,\n      statusDetails: state.result.statusDetails ?? undefined,\n    };\n\n    if (\"folderUri\" in state.result) {\n      state.result.folderUri ??= undefined;\n    }\n  }\n}\n"]}

package/dist/esm/backupClient.d.ts

@@ -1,4 +1,4 @@
-import type { KeyVaultBackupClientOptions, KeyVaultBackupResult, KeyVaultBeginBackupOptions, KeyVaultBeginRestoreOptions, KeyVaultBeginSelectiveKeyRestoreOptions, KeyVaultRestoreResult, KeyVaultSelectiveKeyRestoreResult } from "./backupClientModels.js";
+import type { KeyVaultBackupClientOptions, KeyVaultBackupResult, KeyVaultBeginBackupOptions, KeyVaultBeginPreBackupOptions, KeyVaultBeginPreRestoreOptions, KeyVaultBeginRestoreOptions, KeyVaultBeginSelectiveKeyRestoreOptions, KeyVaultRestoreResult, KeyVaultSelectiveKeyRestoreResult } from "./backupClientModels.js";
 import type { TokenCredential } from "@azure/core-auth";
 import type { PollerLike } from "./lro/shim.js";
 import { KeyVaultAdminPollOperationState, KeyVaultBackupOperationState, KeyVaultRestoreOperationState, KeyVaultSelectiveKeyRestoreOperationState } from "./lro/models.js";
@@ -35,6 +35,134 @@ export declare class KeyVaultBackupClient {
      * @param options - options used to configure Key Vault API requests.
      */
     constructor(vaultUrl: string, credential: TokenCredential, options?: KeyVaultBackupClientOptions);
+    /**
+     * Starts a pre-backup operation which can be used to check whether the customer can perform a {@link beginBackup} operation using the provided SAS token.
+     *
+     * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleBeginPreBackup_SAS
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { KeyVaultBackupClient } from "@azure/keyvault-admin";
+     *
+     * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;
+     * const credentials = new DefaultAzureCredential();
+     * const client = new KeyVaultBackupClient(vaultUrl, credentials);
+     *
+     * const blobStorageUri = "<blob-storage-uri>"; // <Blob storage URL>/<folder name>
+     * const sasToken = "<sas-token>";
+     * const poller = await client.beginPreBackup(blobStorageUri, sasToken);
+     *
+     * // Serializing the poller
+     * const serialized = poller.toString();
+     *
+     * // A new poller can be created with:
+     * await client.beginPreBackup(blobStorageUri, sasToken, { resumeFrom: serialized });
+     *
+     * // Waiting until it's done
+     * const result = await poller.pollUntilDone();
+     * console.log(result);
+     * ```
+     * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.
+     * @param sasToken - The SAS token used to access the blob storage resource.
+     * @param options - The optional parameters.
+     */
+    beginPreBackup(blobStorageUri: string, sasToken: string, options?: KeyVaultBeginPreBackupOptions): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;
+    /**
+     * Starts a pre-backup operation which can be used to check whether the customer can perform a {@link beginBackup} operation using the Managed HSM's configured user-assigned managed identity to authenticate with Azure Storage.
+     *
+     * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleBeginPreBackup_NonSAS
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { KeyVaultBackupClient } from "@azure/keyvault-admin";
+     *
+     * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;
+     * const credentials = new DefaultAzureCredential();
+     * const client = new KeyVaultBackupClient(vaultUrl, credentials);
+     *
+     * const blobStorageUri = "<blob-storage-uri>"; // <Blob storage URL>/<folder name>
+     * const poller = await client.beginPreBackup(blobStorageUri);
+     *
+     * // Serializing the poller
+     * const serialized = poller.toString();
+     *
+     * // A new poller can be created with:
+     * await client.beginPreBackup(blobStorageUri, { resumeFrom: serialized });
+     *
+     * // Waiting until it's done
+     * const result = await poller.pollUntilDone();
+     * console.log(result);
+     * ```
+     * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.
+     * @param options - The optional parameters.
+     */
+    beginPreBackup(blobStorageUri: string, options?: KeyVaultBeginPreBackupOptions): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;
+    /**
+     * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the provided SAS token.
+     *
+     * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleBeginPreRestore_SAS
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { KeyVaultBackupClient } from "@azure/keyvault-admin";
+     *
+     * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;
+     * const credentials = new DefaultAzureCredential();
+     * const client = new KeyVaultBackupClient(vaultUrl, credentials);
+     *
+     * const blobStorageUri = "<blob-storage-uri>"; // <Blob storage URL>/<folder name>
+     * const sasToken = "<sas-token>";
+     * const poller = await client.beginPreRestore(blobStorageUri, sasToken);
+     *
+     * // The poller can be serialized with:
+     * const serialized = poller.toString();
+     *
+     * // A new poller can be created with:
+     * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });
+     *
+     * // Waiting until it's done
+     * await poller.pollUntilDone();
+     * ```
+     * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.
+     * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.
+     * @param options - The optional parameters.
+     */
+    beginPreRestore(folderUri: string, sasToken: string, options?: KeyVaultBeginPreRestoreOptions): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;
+    /**
+     * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the provided SAS token.
+     *
+     * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleBeginPreRestore_SAS
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { KeyVaultBackupClient } from "@azure/keyvault-admin";
+     *
+     * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;
+     * const credentials = new DefaultAzureCredential();
+     * const client = new KeyVaultBackupClient(vaultUrl, credentials);
+     *
+     * const blobStorageUri = "<blob-storage-uri>"; // <Blob storage URL>/<folder name>
+     * const sasToken = "<sas-token>";
+     * const poller = await client.beginPreRestore(blobStorageUri, sasToken);
+     *
+     * // The poller can be serialized with:
+     * const serialized = poller.toString();
+     *
+     * // A new poller can be created with:
+     * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });
+     *
+     * // Waiting until it's done
+     * await poller.pollUntilDone();
+     * ```
+     * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.
+     * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.
+     * @param options - The optional parameters.
+     */
+    beginPreRestore(folderUri: string, options?: KeyVaultBeginPreRestoreOptions): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;
     /**
      * Starts generating a backup of an Azure Key Vault on the specified Storage Blob account.
      *
@@ -162,8 +290,7 @@ export declare class KeyVaultBackupClient {
      * await client.beginRestore(blobStorageUri, { resumeFrom: serialized });
      *
      * // Waiting until it's done
-     * const backupUri = await poller.pollUntilDone();
-     * console.log(backupUri);
+     * await poller.pollUntilDone();
      * ```
      * Starts a full restore operation.
      * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.

package/dist/esm/backupClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backupClient.d.ts","sourceRoot":"","sources":["../../src/backupClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACpB,0BAA0B,EAC1B,2BAA2B,EAC3B,uCAAuC,EACvC,qBAAqB,EACrB,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EACL,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,yCAAyC,EAC1C,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,EAC7B,yCAAyC,EACzC,+BAA+B,GAChC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,oBAAoB;IAC/B;;OAEG;IACH,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAExC;;;;;;;;;;;;;;;OAeG;gBAED,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,eAAe,EAC3B,OAAO,GAAE,2BAAgC;IAO3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACU,WAAW,CACtB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,UAAU,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;IAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACU,WAAW,CACtB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,UAAU,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;IAiC1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACU,YAAY,CACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,UAAU,CAAC,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;IAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACU,YAAY,CACvB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,UAAU,CAAC,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;IAsC5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACU,wBAAwB,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,uCAAuC,GAChD,OAAO,CACR,UAAU,CAAC,yCAAyC,EAAE,iCAAiC,CAAC,CACzF;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACU,wBAAwB,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,uCAAuC,GAChD,OAAO,CACR,UAAU,CAAC,yCAAyC,EAAE,iCAAiC,CAAC,CACzF;CA6CF"}
+{"version":3,"file":"backupClient.d.ts","sourceRoot":"","sources":["../../src/backupClient.ts"],"names":[],"mappings":"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"}

package/dist/esm/backupClient.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { mappings } from "./mappings.js";
 import { createKeyVaultClient } from "./createKeyVaultClient.js";
-import { wrapPoller } from "./lro/shim.js";
+import { wrapPoller, updateState } from "./lro/shim.js";
 import { restorePoller } from "./generated/restorePollerHelpers.js";
 /**
  * The KeyVaultBackupClient provides methods to generate backups
@@ -31,70 +31,163 @@ export class KeyVaultBackupClient {
         this.vaultUrl = vaultUrl;
         this.client = createKeyVaultClient(vaultUrl, credential, options);
     }
+    async beginPreBackup(blobStorageUri, sasTokenOrOptions = {}, optionsWhenSasTokenSpecified = {}) {
+        const sasToken = typeof sasTokenOrOptions === "string" ? sasTokenOrOptions : undefined;
+        const options = typeof sasTokenOrOptions === "string" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;
+        let poller;
+        if (options.resumeFrom) {
+            poller = restorePoller(this.client, options.resumeFrom, this.client.preFullBackup, options);
+        }
+        else {
+            poller = this.client.preFullBackup({
+                storageResourceUri: blobStorageUri,
+                token: sasToken,
+                useManagedIdentity: sasToken === undefined,
+            }, {
+                abortSignal: options.abortSignal,
+                requestOptions: options.requestOptions,
+                onResponse: options.onResponse,
+                tracingOptions: options.tracingOptions,
+                updateIntervalInMs: options.intervalInMs,
+            });
+        }
+        poller.onProgress(updateState);
+        return wrapPoller(poller);
+    }
+    /**
+     * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the Managed HSM's configured user-assigned managed identity to authenticate with Azure Storage.
+     *
+     * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleBeginPreRestore_SAS
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { KeyVaultBackupClient } from "@azure/keyvault-admin";
+     *
+     * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;
+     * const credentials = new DefaultAzureCredential();
+     * const client = new KeyVaultBackupClient(vaultUrl, credentials);
+     *
+     * const blobStorageUri = "<blob-storage-uri>"; // <Blob storage URL>/<folder name>
+     * const sasToken = "<sas-token>";
+     * const poller = await client.beginPreRestore(blobStorageUri, sasToken);
+     *
+     * // The poller can be serialized with:
+     * const serialized = poller.toString();
+     *
+     * // A new poller can be created with:
+     * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });
+     *
+     * // Waiting until it's done
+     * await poller.pollUntilDone();
+     * ```
+     * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.
+     * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.
+     * @param options - The optional parameters.
+     */
+    async beginPreRestore(folderUri, sasTokenOrOptions = {}, optionsWhenSasTokenSpecified = {}) {
+        const sasToken = typeof sasTokenOrOptions === "string" ? sasTokenOrOptions : undefined;
+        const options = typeof sasTokenOrOptions === "string" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;
+        const folderUriParts = mappings.folderUriParts(folderUri);
+        let poller;
+        if (options.resumeFrom) {
+            poller = restorePoller(this.client, options.resumeFrom, this.client.preFullRestoreOperation, options);
+        }
+        else {
+            poller = this.client.preFullRestoreOperation({
+                folderToRestore: folderUriParts.folderName,
+                sasTokenParameters: {
+                    storageResourceUri: folderUriParts.folderUri,
+                    token: sasToken,
+                    useManagedIdentity: sasToken === undefined,
+                },
+            }, {
+                abortSignal: options.abortSignal,
+                requestOptions: options.requestOptions,
+                onResponse: options.onResponse,
+                tracingOptions: options.tracingOptions,
+                updateIntervalInMs: options.intervalInMs,
+            });
+        }
+        poller.onProgress(updateState);
+        return wrapPoller(poller);
+    }
     async beginBackup(blobStorageUri, sasTokenOrOptions = {}, optionsWhenSasTokenSpecified = {}) {
         const sasToken = typeof sasTokenOrOptions === "string" ? sasTokenOrOptions : undefined;
         const options = typeof sasTokenOrOptions === "string" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;
+        let poller;
         if (options.resumeFrom) {
-            return wrapPoller(restorePoller(this.client, options.resumeFrom, this.client.fullBackup, options));
+            poller = restorePoller(this.client, options.resumeFrom, this.client.fullBackup, options);
         }
-        return wrapPoller(this.client.fullBackup({
-            abortSignal: options.abortSignal,
-            requestOptions: options.requestOptions,
-            azureStorageBlobContainerUri: {
+        else {
+            poller = this.client.fullBackup({
                 storageResourceUri: blobStorageUri,
                 token: sasToken,
                 useManagedIdentity: sasToken === undefined,
-            },
-            onResponse: options.onResponse,
-            tracingOptions: options.tracingOptions,
-            updateIntervalInMs: options.intervalInMs,
-        }));
+            }, {
+                abortSignal: options.abortSignal,
+                requestOptions: options.requestOptions,
+                onResponse: options.onResponse,
+                tracingOptions: options.tracingOptions,
+                updateIntervalInMs: options.intervalInMs,
+            });
+        }
+        poller.onProgress(updateState);
+        return wrapPoller(poller);
     }
     async beginRestore(folderUri, sasTokenOrOptions = {}, optionsWhenSasTokenSpecified = {}) {
         const sasToken = typeof sasTokenOrOptions === "string" ? sasTokenOrOptions : undefined;
         const options = typeof sasTokenOrOptions === "string" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;
         const folderUriParts = mappings.folderUriParts(folderUri);
+        let poller;
         if (options.resumeFrom) {
-            return wrapPoller(restorePoller(this.client, options.resumeFrom, this.client.fullRestoreOperation, options));
+            poller = restorePoller(this.client, options.resumeFrom, this.client.fullRestoreOperation, options);
         }
-        return wrapPoller(this.client.fullRestoreOperation({
-            abortSignal: options.abortSignal,
-            requestOptions: options.requestOptions,
-            restoreBlobDetails: {
+        else {
+            poller = this.client.fullRestoreOperation({
                 folderToRestore: folderUriParts.folderName,
                 sasTokenParameters: {
                     storageResourceUri: folderUriParts.folderUri,
                     token: sasToken,
                     useManagedIdentity: sasToken === undefined,
                 },
-            },
-            onResponse: options.onResponse,
-            tracingOptions: options.tracingOptions,
-            updateIntervalInMs: options.intervalInMs,
-        }));
+            }, {
+                abortSignal: options.abortSignal,
+                requestOptions: options.requestOptions,
+                onResponse: options.onResponse,
+                tracingOptions: options.tracingOptions,
+                updateIntervalInMs: options.intervalInMs,
+            });
+        }
+        poller.onProgress(updateState);
+        return wrapPoller(poller);
     }
     async beginSelectiveKeyRestore(keyName, folderUri, sasTokenOrOptions = {}, optionsWhenSasTokenSpecified = {}) {
         const sasToken = typeof sasTokenOrOptions === "string" ? sasTokenOrOptions : undefined;
         const options = typeof sasTokenOrOptions === "string" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;
         const folderUriParts = mappings.folderUriParts(folderUri);
+        let poller;
         if (options.resumeFrom) {
-            return wrapPoller(restorePoller(this.client, options.resumeFrom, this.client.selectiveKeyRestoreOperation, options));
+            poller = restorePoller(this.client, options.resumeFrom, this.client.selectiveKeyRestoreOperation, options);
         }
-        return wrapPoller(this.client.selectiveKeyRestoreOperation(keyName, {
-            abortSignal: options.abortSignal,
-            requestOptions: options.requestOptions,
-            onResponse: options.onResponse,
-            restoreBlobDetails: {
+        else {
+            poller = this.client.selectiveKeyRestoreOperation(keyName, {
                 folder: folderUriParts.folderName,
                 sasTokenParameters: {
                     storageResourceUri: folderUriParts.folderUri,
                     token: sasToken,
                     useManagedIdentity: sasToken === undefined,
                 },
-            },
-            tracingOptions: options.tracingOptions,
-            updateIntervalInMs: options.intervalInMs,
-        }));
+            }, {
+                abortSignal: options.abortSignal,
+                requestOptions: options.requestOptions,
+                onResponse: options.onResponse,
+                tracingOptions: options.tracingOptions,
+                updateIntervalInMs: options.intervalInMs,
+            });
+        }
+        poller.onProgress(updateState);
+        return wrapPoller(poller);
     }
 }
 //# sourceMappingURL=backupClient.js.map

package/dist/esm/backupClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"backupClient.js","sourceRoot":"","sources":["../../src/backupClient.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type {\n  KeyVaultBackupClientOptions,\n  KeyVaultBackupResult,\n  KeyVaultBeginBackupOptions,\n  KeyVaultBeginRestoreOptions,\n  KeyVaultBeginSelectiveKeyRestoreOptions,\n  KeyVaultRestoreResult,\n  KeyVaultSelectiveKeyRestoreResult,\n} from \"./backupClientModels.js\";\nimport type { KeyVaultClient } from \"./generated/keyVaultClient.js\";\nimport type { TokenCredential } from \"@azure/core-auth\";\nimport { mappings } from \"./mappings.js\";\nimport { createKeyVaultClient } from \"./createKeyVaultClient.js\";\nimport type { PollerLike } from \"./lro/shim.js\";\nimport { wrapPoller } from \"./lro/shim.js\";\nimport {\n  KeyVaultAdminPollOperationState,\n  KeyVaultBackupOperationState,\n  KeyVaultRestoreOperationState,\n  KeyVaultSelectiveKeyRestoreOperationState,\n} from \"./lro/models.js\";\nimport { restorePoller } from \"./generated/restorePollerHelpers.js\";\n\nexport {\n  KeyVaultBackupOperationState,\n  KeyVaultRestoreOperationState,\n  KeyVaultSelectiveKeyRestoreOperationState,\n  KeyVaultAdminPollOperationState,\n};\n\n/**\n * The KeyVaultBackupClient provides methods to generate backups\n * and restore backups of any given Azure Key Vault instance.\n * This client supports generating full backups, selective restores of specific keys\n * and full restores of Key Vault instances.\n */\nexport class KeyVaultBackupClient {\n  /**\n   * The base URL to the vault\n   */\n  public readonly vaultUrl: string;\n\n  /**\n   * A reference to the auto-generated Key Vault HTTP client.\n   */\n  private readonly client: KeyVaultClient;\n\n  /**\n   * Creates an instance of the KeyVaultBackupClient.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleCreateBackupClient\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   * ```\n   * @param vaultUrl - the URL of the Key Vault. It should have this shape: `https://${your-key-vault-name}.vault.azure.net`. You should validate that this URL references a valid Key Vault or Managed HSM resource. See https://aka.ms/azsdk/blog/vault-uri for details.\n   * @param credential - An object that implements the `TokenCredential` interface used to authenticate requests to the service. Use the \\@azure/identity package to create a credential that suits your needs.\n   * @param options - options used to configure Key Vault API requests.\n   */\n  constructor(\n    vaultUrl: string,\n    credential: TokenCredential,\n    options: KeyVaultBackupClientOptions = {},\n  ) {\n    this.vaultUrl = vaultUrl;\n\n    this.client = createKeyVaultClient(vaultUrl, credential, options);\n  }\n\n  /**\n   * Starts generating a backup of an Azure Key Vault on the specified Storage Blob account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault backup is generated.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginBackup_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginBackup(blobStorageUri, sasToken);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginBackup(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full backup operation.\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param sasToken - The SAS token used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginBackup(\n    blobStorageUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n\n  /**\n   * Starts generating a backup of an Azure Key Vault on the specified Storage Blob account, using a user-assigned Managed Identity\n   * to access the Storage account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault backup is generated.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginBackup_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const poller = await client.beginBackup(blobStorageUri);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginBackup(blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full backup operation.\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param options - The optional parameters.\n   */\n  public async beginBackup(\n    blobStorageUri: string,\n    options?: KeyVaultBeginBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n\n  public async beginBackup(\n    blobStorageUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginBackupOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginBackupOptions = {},\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    if (options.resumeFrom) {\n      return wrapPoller(\n        restorePoller(this.client, options.resumeFrom, this.client.fullBackup, options),\n      );\n    }\n\n    return wrapPoller(\n      this.client.fullBackup({\n        abortSignal: options.abortSignal,\n        requestOptions: options.requestOptions,\n        azureStorageBlobContainerUri: {\n          storageResourceUri: blobStorageUri,\n          token: sasToken,\n          useManagedIdentity: sasToken === undefined,\n        },\n        onResponse: options.onResponse,\n        tracingOptions: options.tracingOptions,\n        updateIntervalInMs: options.intervalInMs,\n      }),\n    );\n  }\n\n  /**\n   * Starts restoring all key materials using the SAS token pointing to a previously stored Azure Blob storage\n   * backup folder.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault restore operation is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginRestore(blobStorageUri, sasToken);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginRestore(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full restore operation.\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginRestore(\n    folderUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n\n  /**\n   * Starts restoring all key materials using the SAS token pointing to a previously stored Azure Blob storage\n   * backup folder, using a user-assigned Managed Identity to access the storage account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault restore operation is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginRestore_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const poller = await client.beginRestore(blobStorageUri);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginRestore(blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full restore operation.\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginRestore(\n    folderUri: string,\n    options?: KeyVaultBeginRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n\n  public async beginRestore(\n    folderUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginRestoreOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginRestoreOptions = {},\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    const folderUriParts = mappings.folderUriParts(folderUri);\n\n    if (options.resumeFrom) {\n      return wrapPoller(\n        restorePoller(this.client, options.resumeFrom, this.client.fullRestoreOperation, options),\n      );\n    }\n\n    return wrapPoller(\n      this.client.fullRestoreOperation({\n        abortSignal: options.abortSignal,\n        requestOptions: options.requestOptions,\n        restoreBlobDetails: {\n          folderToRestore: folderUriParts.folderName,\n          sasTokenParameters: {\n            storageResourceUri: folderUriParts.folderUri,\n            token: sasToken,\n            useManagedIdentity: sasToken === undefined,\n          },\n        },\n        onResponse: options.onResponse,\n        tracingOptions: options.tracingOptions,\n        updateIntervalInMs: options.intervalInMs,\n      }),\n    );\n  }\n\n  /**\n   * Starts restoring all key versions of a given key using user supplied SAS token pointing to a previously\n   * stored Azure Blob storage backup folder.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault selective restore is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginSelectiveKeyRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\";\n   * const sasToken = \"<sas-token>\";\n   * const keyName = \"<key-name>\";\n   * const poller = await client.beginSelectiveKeyRestore(keyName, blobStorageUri, sasToken);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginSelectiveKeyRestore(keyName, blobStorageUri, sasToken, {\n   *   resumeFrom: serialized,\n   * });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * Creates a new role assignment.\n   * @param keyName - The name of the key that wants to be restored.\n   * @param folderUri - The URL of the blob storage resource, with the folder name of the blob where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginSelectiveKeyRestoreOptions,\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  >;\n\n  /**\n   * Starts restoring all key versions of a given key using to a previously\n   * stored Azure Blob storage backup folder. The Blob storage backup folder will be accessed using user-assigned Managed Identity.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault selective restore is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginSelectiveKeyRestore_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\";\n   * const keyName = \"<key-name>\";\n   * const poller = await client.beginSelectiveKeyRestore(keyName, blobStorageUri);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginSelectiveKeyRestore(keyName, blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * Creates a new role assignment.\n   * @param keyName - The name of the key that wants to be restored.\n   * @param folderUri - The URL of the blob storage resource, with the folder name of the blob where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    options?: KeyVaultBeginSelectiveKeyRestoreOptions,\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  >;\n\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginSelectiveKeyRestoreOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginSelectiveKeyRestoreOptions = {},\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  > {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    const folderUriParts = mappings.folderUriParts(folderUri);\n\n    if (options.resumeFrom) {\n      return wrapPoller(\n        restorePoller(\n          this.client,\n          options.resumeFrom,\n          this.client.selectiveKeyRestoreOperation,\n          options,\n        ),\n      );\n    }\n\n    return wrapPoller(\n      this.client.selectiveKeyRestoreOperation(keyName, {\n        abortSignal: options.abortSignal,\n        requestOptions: options.requestOptions,\n        onResponse: options.onResponse,\n        restoreBlobDetails: {\n          folder: folderUriParts.folderName,\n          sasTokenParameters: {\n            storageResourceUri: folderUriParts.folderUri,\n            token: sasToken,\n            useManagedIdentity: sasToken === undefined,\n          },\n        },\n        tracingOptions: options.tracingOptions,\n        updateIntervalInMs: options.intervalInMs,\n      }),\n    );\n  }\n}\n"]}
+{"version":3,"file":"backupClient.js","sourceRoot":"","sources":["../../src/backupClient.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type {\n  KeyVaultBackupClientOptions,\n  KeyVaultBackupResult,\n  KeyVaultBeginBackupOptions,\n  KeyVaultBeginPreBackupOptions,\n  KeyVaultBeginPreRestoreOptions,\n  KeyVaultBeginRestoreOptions,\n  KeyVaultBeginSelectiveKeyRestoreOptions,\n  KeyVaultRestoreResult,\n  KeyVaultSelectiveKeyRestoreResult,\n} from \"./backupClientModels.js\";\nimport type { KeyVaultClient } from \"./generated/keyVaultClient.js\";\nimport type { TokenCredential } from \"@azure/core-auth\";\nimport { mappings } from \"./mappings.js\";\nimport { createKeyVaultClient } from \"./createKeyVaultClient.js\";\nimport type { PollerLike } from \"./lro/shim.js\";\nimport { wrapPoller, updateState } from \"./lro/shim.js\";\nimport {\n  KeyVaultAdminPollOperationState,\n  KeyVaultBackupOperationState,\n  KeyVaultRestoreOperationState,\n  KeyVaultSelectiveKeyRestoreOperationState,\n} from \"./lro/models.js\";\nimport { restorePoller } from \"./generated/restorePollerHelpers.js\";\n\nexport {\n  KeyVaultBackupOperationState,\n  KeyVaultRestoreOperationState,\n  KeyVaultSelectiveKeyRestoreOperationState,\n  KeyVaultAdminPollOperationState,\n};\n\n/**\n * The KeyVaultBackupClient provides methods to generate backups\n * and restore backups of any given Azure Key Vault instance.\n * This client supports generating full backups, selective restores of specific keys\n * and full restores of Key Vault instances.\n */\nexport class KeyVaultBackupClient {\n  /**\n   * The base URL to the vault\n   */\n  public readonly vaultUrl: string;\n\n  /**\n   * A reference to the auto-generated Key Vault HTTP client.\n   */\n  private readonly client: KeyVaultClient;\n\n  /**\n   * Creates an instance of the KeyVaultBackupClient.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleCreateBackupClient\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   * ```\n   * @param vaultUrl - the URL of the Key Vault. It should have this shape: `https://${your-key-vault-name}.vault.azure.net`. You should validate that this URL references a valid Key Vault or Managed HSM resource. See https://aka.ms/azsdk/blog/vault-uri for details.\n   * @param credential - An object that implements the `TokenCredential` interface used to authenticate requests to the service. Use the \\@azure/identity package to create a credential that suits your needs.\n   * @param options - options used to configure Key Vault API requests.\n   */\n  constructor(\n    vaultUrl: string,\n    credential: TokenCredential,\n    options: KeyVaultBackupClientOptions = {},\n  ) {\n    this.vaultUrl = vaultUrl;\n\n    this.client = createKeyVaultClient(vaultUrl, credential, options);\n  }\n\n  /**\n   * Starts a pre-backup operation which can be used to check whether the customer can perform a {@link beginBackup} operation using the provided SAS token.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginPreBackup_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginPreBackup(blobStorageUri, sasToken);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginPreBackup(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const result = await poller.pollUntilDone();\n   * console.log(result);\n   * ```\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param sasToken - The SAS token used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginPreBackup(\n    blobStorageUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginPreBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n  /**\n   * Starts a pre-backup operation which can be used to check whether the customer can perform a {@link beginBackup} operation using the Managed HSM's configured user-assigned managed identity to authenticate with Azure Storage.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginPreBackup_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const poller = await client.beginPreBackup(blobStorageUri);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginPreBackup(blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const result = await poller.pollUntilDone();\n   * console.log(result);\n   * ```\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param options - The optional parameters.\n   */\n  public async beginPreBackup(\n    blobStorageUri: string,\n    options?: KeyVaultBeginPreBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n  public async beginPreBackup(\n    blobStorageUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginPreBackupOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginPreBackupOptions = {},\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    let poller;\n    if (options.resumeFrom) {\n      poller = restorePoller(this.client, options.resumeFrom, this.client.preFullBackup, options);\n    } else {\n      poller = this.client.preFullBackup(\n        {\n          storageResourceUri: blobStorageUri,\n          token: sasToken,\n          useManagedIdentity: sasToken === undefined,\n        },\n        {\n          abortSignal: options.abortSignal,\n          requestOptions: options.requestOptions,\n          onResponse: options.onResponse,\n          tracingOptions: options.tracingOptions,\n          updateIntervalInMs: options.intervalInMs,\n        },\n      );\n    }\n\n    poller.onProgress(updateState);\n\n    return wrapPoller(poller) as ReturnType<typeof this.beginPreBackup>;\n  }\n\n  /**\n   * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the provided SAS token.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginPreRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginPreRestore(blobStorageUri, sasToken);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginPreRestore(\n    folderUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginPreRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n  /**\n   * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the provided SAS token.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginPreRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginPreRestore(blobStorageUri, sasToken);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginPreRestore(\n    folderUri: string,\n    options?: KeyVaultBeginPreRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n  /**\n   * Starts a pre-restore operation which can be used to check whether the customer can perform a {@link beginRestore} operation using the Managed HSM's configured user-assigned managed identity to authenticate with Azure Storage.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the operation completes.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginPreRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginPreRestore(blobStorageUri, sasToken);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginPreRestore(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginPreRestore(\n    folderUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginPreRestoreOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginPreRestoreOptions = {},\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    const folderUriParts = mappings.folderUriParts(folderUri);\n\n    let poller;\n    if (options.resumeFrom) {\n      poller = restorePoller(\n        this.client,\n        options.resumeFrom,\n        this.client.preFullRestoreOperation,\n        options,\n      );\n    } else {\n      poller = this.client.preFullRestoreOperation(\n        {\n          folderToRestore: folderUriParts.folderName,\n          sasTokenParameters: {\n            storageResourceUri: folderUriParts.folderUri,\n            token: sasToken,\n            useManagedIdentity: sasToken === undefined,\n          },\n        },\n        {\n          abortSignal: options.abortSignal,\n          requestOptions: options.requestOptions,\n          onResponse: options.onResponse,\n          tracingOptions: options.tracingOptions,\n          updateIntervalInMs: options.intervalInMs,\n        },\n      );\n    }\n    poller.onProgress(updateState);\n\n    return wrapPoller(poller) as ReturnType<typeof this.beginPreRestore>;\n  }\n\n  /**\n   * Starts generating a backup of an Azure Key Vault on the specified Storage Blob account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault backup is generated.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginBackup_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginBackup(blobStorageUri, sasToken);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginBackup(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full backup operation.\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param sasToken - The SAS token used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginBackup(\n    blobStorageUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n\n  /**\n   * Starts generating a backup of an Azure Key Vault on the specified Storage Blob account, using a user-assigned Managed Identity\n   * to access the Storage account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault backup is generated.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginBackup_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const poller = await client.beginBackup(blobStorageUri);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginBackup(blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full backup operation.\n   * @param blobStorageUri - The URL of the blob storage resource, including the path to the container where the backup will end up being stored.\n   * @param options - The optional parameters.\n   */\n  public async beginBackup(\n    blobStorageUri: string,\n    options?: KeyVaultBeginBackupOptions,\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>>;\n\n  public async beginBackup(\n    blobStorageUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginBackupOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginBackupOptions = {},\n  ): Promise<PollerLike<KeyVaultBackupOperationState, KeyVaultBackupResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    let poller;\n    if (options.resumeFrom) {\n      poller = restorePoller(this.client, options.resumeFrom, this.client.fullBackup, options);\n    } else {\n      poller = this.client.fullBackup(\n        {\n          storageResourceUri: blobStorageUri,\n          token: sasToken,\n          useManagedIdentity: sasToken === undefined,\n        },\n        {\n          abortSignal: options.abortSignal,\n          requestOptions: options.requestOptions,\n          onResponse: options.onResponse,\n          tracingOptions: options.tracingOptions,\n          updateIntervalInMs: options.intervalInMs,\n        },\n      );\n    }\n\n    poller.onProgress(updateState);\n\n    return wrapPoller(poller) as ReturnType<typeof this.beginBackup>;\n  }\n\n  /**\n   * Starts restoring all key materials using the SAS token pointing to a previously stored Azure Blob storage\n   * backup folder.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault restore operation is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const sasToken = \"<sas-token>\";\n   * const poller = await client.beginRestore(blobStorageUri, sasToken);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginRestore(blobStorageUri, sasToken, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * const backupUri = await poller.pollUntilDone();\n   * console.log(backupUri);\n   * ```\n   * Starts a full restore operation.\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginRestore(\n    folderUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n\n  /**\n   * Starts restoring all key materials using the SAS token pointing to a previously stored Azure Blob storage\n   * backup folder, using a user-assigned Managed Identity to access the storage account.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault restore operation is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginRestore_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\"; // <Blob storage URL>/<folder name>\n   * const poller = await client.beginRestore(blobStorageUri);\n   *\n   * // The poller can be serialized with:\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginRestore(blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * Starts a full restore operation.\n   * @param folderUri - The URL of the blob storage resource where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginRestore(\n    folderUri: string,\n    options?: KeyVaultBeginRestoreOptions,\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>>;\n\n  public async beginRestore(\n    folderUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginRestoreOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginRestoreOptions = {},\n  ): Promise<PollerLike<KeyVaultRestoreOperationState, KeyVaultRestoreResult>> {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    const folderUriParts = mappings.folderUriParts(folderUri);\n\n    let poller;\n    if (options.resumeFrom) {\n      poller = restorePoller(\n        this.client,\n        options.resumeFrom,\n        this.client.fullRestoreOperation,\n        options,\n      );\n    } else {\n      poller = this.client.fullRestoreOperation(\n        {\n          folderToRestore: folderUriParts.folderName,\n          sasTokenParameters: {\n            storageResourceUri: folderUriParts.folderUri,\n            token: sasToken,\n            useManagedIdentity: sasToken === undefined,\n          },\n        },\n        {\n          abortSignal: options.abortSignal,\n          requestOptions: options.requestOptions,\n          onResponse: options.onResponse,\n          tracingOptions: options.tracingOptions,\n          updateIntervalInMs: options.intervalInMs,\n        },\n      );\n    }\n    poller.onProgress(updateState);\n\n    return wrapPoller(poller) as ReturnType<typeof this.beginRestore>;\n  }\n\n  /**\n   * Starts restoring all key versions of a given key using user supplied SAS token pointing to a previously\n   * stored Azure Blob storage backup folder.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault selective restore is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginSelectiveKeyRestore_SAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\";\n   * const sasToken = \"<sas-token>\";\n   * const keyName = \"<key-name>\";\n   * const poller = await client.beginSelectiveKeyRestore(keyName, blobStorageUri, sasToken);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginSelectiveKeyRestore(keyName, blobStorageUri, sasToken, {\n   *   resumeFrom: serialized,\n   * });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * Creates a new role assignment.\n   * @param keyName - The name of the key that wants to be restored.\n   * @param folderUri - The URL of the blob storage resource, with the folder name of the blob where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    sasToken: string,\n    options?: KeyVaultBeginSelectiveKeyRestoreOptions,\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  >;\n\n  /**\n   * Starts restoring all key versions of a given key using to a previously\n   * stored Azure Blob storage backup folder. The Blob storage backup folder will be accessed using user-assigned Managed Identity.\n   *\n   * This function returns a Long Running Operation poller that allows you to wait indefinitely until the Key Vault selective restore is complete.\n   *\n   * Example usage:\n   * ```ts snippet:ReadmeSampleBeginSelectiveKeyRestore_NonSAS\n   * import { DefaultAzureCredential } from \"@azure/identity\";\n   * import { KeyVaultBackupClient } from \"@azure/keyvault-admin\";\n   *\n   * const vaultUrl = `https://<MY KEY VAULT HERE>.vault.azure.net`;\n   * const credentials = new DefaultAzureCredential();\n   * const client = new KeyVaultBackupClient(vaultUrl, credentials);\n   *\n   * const blobStorageUri = \"<blob-storage-uri>\";\n   * const keyName = \"<key-name>\";\n   * const poller = await client.beginSelectiveKeyRestore(keyName, blobStorageUri);\n   *\n   * // Serializing the poller\n   * const serialized = poller.toString();\n   *\n   * // A new poller can be created with:\n   * await client.beginSelectiveKeyRestore(keyName, blobStorageUri, { resumeFrom: serialized });\n   *\n   * // Waiting until it's done\n   * await poller.pollUntilDone();\n   * ```\n   * Creates a new role assignment.\n   * @param keyName - The name of the key that wants to be restored.\n   * @param folderUri - The URL of the blob storage resource, with the folder name of the blob where the previous successful full backup was stored.\n   * @param sasToken - The SAS token. If no SAS token is provided, user-assigned Managed Identity will be used to access the blob storage resource.\n   * @param options - The optional parameters.\n   */\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    options?: KeyVaultBeginSelectiveKeyRestoreOptions,\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  >;\n\n  public async beginSelectiveKeyRestore(\n    keyName: string,\n    folderUri: string,\n    sasTokenOrOptions: string | KeyVaultBeginSelectiveKeyRestoreOptions = {},\n    optionsWhenSasTokenSpecified: KeyVaultBeginSelectiveKeyRestoreOptions = {},\n  ): Promise<\n    PollerLike<KeyVaultSelectiveKeyRestoreOperationState, KeyVaultSelectiveKeyRestoreResult>\n  > {\n    const sasToken = typeof sasTokenOrOptions === \"string\" ? sasTokenOrOptions : undefined;\n    const options =\n      typeof sasTokenOrOptions === \"string\" ? optionsWhenSasTokenSpecified : sasTokenOrOptions;\n\n    const folderUriParts = mappings.folderUriParts(folderUri);\n\n    let poller;\n    if (options.resumeFrom) {\n      poller = restorePoller(\n        this.client,\n        options.resumeFrom,\n        this.client.selectiveKeyRestoreOperation,\n        options,\n      );\n    } else {\n      poller = this.client.selectiveKeyRestoreOperation(\n        keyName,\n        {\n          folder: folderUriParts.folderName,\n          sasTokenParameters: {\n            storageResourceUri: folderUriParts.folderUri,\n            token: sasToken,\n            useManagedIdentity: sasToken === undefined,\n          },\n        },\n        {\n          abortSignal: options.abortSignal,\n          requestOptions: options.requestOptions,\n          onResponse: options.onResponse,\n          tracingOptions: options.tracingOptions,\n          updateIntervalInMs: options.intervalInMs,\n        },\n      );\n    }\n    poller.onProgress(updateState);\n\n    return wrapPoller(poller) as ReturnType<typeof this.beginSelectiveKeyRestore>;\n  }\n}\n"]}

package/dist/esm/backupClientModels.d.ts

@@ -32,19 +32,31 @@ export interface KeyVaultBackupPollerOptions extends OperationOptions {
 }
 /**
  * An interface representing the optional parameters that can be
- * passed to {@link beginBackup}
+ * passed to {@link KeyVaultBackupClient.beginPreBackup}
+ */
+export interface KeyVaultBeginPreBackupOptions extends KeyVaultBackupPollerOptions {
+}
+/**
+ * An interface representing the optional parameters that can be
+ * passed to {@link KeyVaultBackupClient.beginBackup}
  */
 export interface KeyVaultBeginBackupOptions extends KeyVaultBackupPollerOptions {
 }
 /**
  * An interface representing the optional parameters that can be
- * passed to {@link beginRestore}
+ * passed to {@link KeyVaultBackupClient.beginRestore}
  */
 export interface KeyVaultBeginRestoreOptions extends KeyVaultBackupPollerOptions {
 }
 /**
  * An interface representing the optional parameters that can be
- * passed to {@link beginSelectiveKeyRestore}
+ * passed to {@link KeyVaultBackupClient.beginPreRestore}
+ */
+export interface KeyVaultBeginPreRestoreOptions extends KeyVaultBackupPollerOptions {
+}
+/**
+ * An interface representing the optional parameters that can be
+ * passed to {@link KeyVaultBackupClient.beginSelectiveKeyRestore}
  */
 export interface KeyVaultBeginSelectiveKeyRestoreOptions extends KeyVaultBackupPollerOptions {
 }

package/dist/esm/backupClientModels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backupClientModels.d.ts","sourceRoot":"","sources":["../../src/backupClientModels.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE7D,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,aAAa;IAChE;;OAEG;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IAExC;;;OAGG;IACH,oCAAoC,CAAC,EAAE,OAAO,CAAC;CAChD;AAED;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,2BAA2B;CAAG;AAElF;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,2BAA2B;CAAG;AAEnF;;;GAGG;AACH,MAAM,WAAW,uCAAwC,SAAQ,2BAA2B;CAAG;AAE/F;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB"}
+{"version":3,"file":"backupClientModels.d.ts","sourceRoot":"","sources":["../../src/backupClientModels.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAG7D,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,aAAa;IAChE;;OAEG;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IAExC;;;OAGG;IACH,oCAAoC,CAAC,EAAE,OAAO,CAAC;CAChD;AAED;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,6BAA8B,SAAQ,2BAA2B;CAAG;AAErF;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,2BAA2B;CAAG;AAElF;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,2BAA2B;CAAG;AAEnF;;;GAGG;AACH,MAAM,WAAW,8BAA+B,SAAQ,2BAA2B;CAAG;AAEtF;;;GAGG;AACH,MAAM,WAAW,uCAAwC,SAAQ,2BAA2B;CAAG;AAE/F;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB"}

package/dist/esm/backupClientModels.js.map

@@ -1 +1 @@
-{"version":3,"file":"backupClientModels.js","sourceRoot":"","sources":["../../src/backupClientModels.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { ClientOptions, OperationOptions } from \"@azure-rest/core-client\";\nimport type { SUPPORTED_API_VERSIONS } from \"./constants.js\";\n\nexport type { PollerLike } from \"./lro/shim.js\";\nexport type { OperationStatus } from \"./generated/index.js\";\n\n/**\n * The optional parameters accepted by the KeyVaultBackupClient\n */\nexport interface KeyVaultBackupClientOptions extends ClientOptions {\n  /**\n   * The accepted versions of the Key Vault's service API.\n   */\n  serviceVersion?: SUPPORTED_API_VERSIONS;\n\n  /**\n   * Whether to disable verification that the authentication challenge resource matches the Key Vault or Managed HSM domain.\n   * Defaults to false.\n   */\n  disableChallengeResourceVerification?: boolean;\n}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link beginBackup}\n */\nexport interface KeyVaultBackupPollerOptions extends OperationOptions {\n  /**\n   * Time between each polling\n   */\n  intervalInMs?: number;\n  /**\n   * A serialized poller, used to resume an existing operation\n   */\n  resumeFrom?: string;\n}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link beginBackup}\n */\nexport interface KeyVaultBeginBackupOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link beginRestore}\n */\nexport interface KeyVaultBeginRestoreOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link beginSelectiveKeyRestore}\n */\nexport interface KeyVaultBeginSelectiveKeyRestoreOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the result of a backup operation.\n */\nexport interface KeyVaultBackupResult {\n  /**\n   * The location of the full backup.\n   */\n  folderUri?: string;\n\n  /**\n   * The start time of the backup operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the backup operation.\n   */\n  endTime?: Date;\n}\n\n/**\n * An interface representing the result of a restore operation.\n */\nexport interface KeyVaultRestoreResult {\n  /**\n   * The start time of the restore operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the restore operation.\n   */\n  endTime?: Date;\n}\n\n/**\n * An interface representing the result of a selective key restore operation.\n */\nexport interface KeyVaultSelectiveKeyRestoreResult {\n  /**\n   * The start time of the selective key restore operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the selective key restore operation.\n   */\n  endTime?: Date;\n}\n"]}
+{"version":3,"file":"backupClientModels.js","sourceRoot":"","sources":["../../src/backupClientModels.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { ClientOptions, OperationOptions } from \"@azure-rest/core-client\";\nimport type { SUPPORTED_API_VERSIONS } from \"./constants.js\";\nimport { KeyVaultBackupClient } from \"./backupClient.js\";\n\nexport type { PollerLike } from \"./lro/shim.js\";\nexport type { OperationStatus } from \"./generated/index.js\";\n\n/**\n * The optional parameters accepted by the KeyVaultBackupClient\n */\nexport interface KeyVaultBackupClientOptions extends ClientOptions {\n  /**\n   * The accepted versions of the Key Vault's service API.\n   */\n  serviceVersion?: SUPPORTED_API_VERSIONS;\n\n  /**\n   * Whether to disable verification that the authentication challenge resource matches the Key Vault or Managed HSM domain.\n   * Defaults to false.\n   */\n  disableChallengeResourceVerification?: boolean;\n}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link beginBackup}\n */\nexport interface KeyVaultBackupPollerOptions extends OperationOptions {\n  /**\n   * Time between each polling\n   */\n  intervalInMs?: number;\n  /**\n   * A serialized poller, used to resume an existing operation\n   */\n  resumeFrom?: string;\n}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link KeyVaultBackupClient.beginPreBackup}\n */\nexport interface KeyVaultBeginPreBackupOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link KeyVaultBackupClient.beginBackup}\n */\nexport interface KeyVaultBeginBackupOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link KeyVaultBackupClient.beginRestore}\n */\nexport interface KeyVaultBeginRestoreOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link KeyVaultBackupClient.beginPreRestore}\n */\nexport interface KeyVaultBeginPreRestoreOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the optional parameters that can be\n * passed to {@link KeyVaultBackupClient.beginSelectiveKeyRestore}\n */\nexport interface KeyVaultBeginSelectiveKeyRestoreOptions extends KeyVaultBackupPollerOptions {}\n\n/**\n * An interface representing the result of a backup operation.\n */\nexport interface KeyVaultBackupResult {\n  /**\n   * The location of the full backup.\n   */\n  folderUri?: string;\n\n  /**\n   * The start time of the backup operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the backup operation.\n   */\n  endTime?: Date;\n}\n\n/**\n * An interface representing the result of a restore operation.\n */\nexport interface KeyVaultRestoreResult {\n  /**\n   * The start time of the restore operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the restore operation.\n   */\n  endTime?: Date;\n}\n\n/**\n * An interface representing the result of a selective key restore operation.\n */\nexport interface KeyVaultSelectiveKeyRestoreResult {\n  /**\n   * The start time of the selective key restore operation.\n   */\n  startTime?: Date;\n\n  /**\n   * The end time of the selective key restore operation.\n   */\n  endTime?: Date;\n}\n"]}

package/dist/esm/constants.d.ts

@@ -5,9 +5,9 @@ export declare const SDK_VERSION: string;
 /**
  * The latest supported Key Vault service API version.
  */
-export declare const LATEST_API_VERSION = "7.5";
+export declare const LATEST_API_VERSION = "7.6-preview.2";
 /**
  * Supported API versions
  */
-export type SUPPORTED_API_VERSIONS = "7.2" | "7.3" | "7.4" | "7.5";
+export type SUPPORTED_API_VERSIONS = "7.2" | "7.3" | "7.4" | "7.5" | "7.6-preview.2";
 //# sourceMappingURL=constants.d.ts.map

package/dist/esm/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,MAAgB,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,MAAuB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,eAAe,CAAC"}