@azure/arm-confidentialledger 1.3.0-beta.1 → 1.3.0-beta.2

package/review/arm-confidentialledger.api.md

@@ -58,6 +58,17 @@ export interface ConfidentialLedger extends TrackedResource {
     properties?: LedgerProperties;
 }
 
+// @public
+export interface ConfidentialLedgerBackup {
+    restoreRegion?: string;
+    uri: string;
+}
+
+// @public
+export interface ConfidentialLedgerBackupResponse {
+    readonly message?: string;
+}
+
 // @public (undocumented)
 export class ConfidentialLedgerClient extends coreClient.ServiceClient {
     // (undocumented)
@@ -89,6 +100,18 @@ export interface ConfidentialLedgerList {
     value?: ConfidentialLedger[];
 }
 
+// @public
+export interface ConfidentialLedgerRestore {
+    fileShareName: string;
+    restoreRegion: string;
+    uri: string;
+}
+
+// @public
+export interface ConfidentialLedgerRestoreResponse {
+    readonly message?: string;
+}
+
 // @public
 export type CreatedByType = string;
 
@@ -148,6 +171,13 @@ export enum KnownLedgerRoleName {
     Reader = "Reader"
 }
 
+// @public
+export enum KnownLedgerSku {
+    Basic = "Basic",
+    Standard = "Standard",
+    Unknown = "Unknown"
+}
+
 // @public
 export enum KnownLedgerType {
     Private = "Private",
@@ -180,10 +210,14 @@ export type LanguageRuntime = string;
 
 // @public
 export interface Ledger {
+    beginBackup(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedgerBackup, options?: LedgerBackupOptionalParams): Promise<SimplePollerLike<OperationState<LedgerBackupResponse>, LedgerBackupResponse>>;
+    beginBackupAndWait(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedgerBackup, options?: LedgerBackupOptionalParams): Promise<LedgerBackupResponse>;
     beginCreate(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedger, options?: LedgerCreateOptionalParams): Promise<SimplePollerLike<OperationState<LedgerCreateResponse>, LedgerCreateResponse>>;
     beginCreateAndWait(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedger, options?: LedgerCreateOptionalParams): Promise<LedgerCreateResponse>;
     beginDelete(resourceGroupName: string, ledgerName: string, options?: LedgerDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
     beginDeleteAndWait(resourceGroupName: string, ledgerName: string, options?: LedgerDeleteOptionalParams): Promise<void>;
+    beginRestore(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedgerRestore, options?: LedgerRestoreOptionalParams): Promise<SimplePollerLike<OperationState<LedgerRestoreResponse>, LedgerRestoreResponse>>;
+    beginRestoreAndWait(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedgerRestore, options?: LedgerRestoreOptionalParams): Promise<LedgerRestoreResponse>;
     beginUpdate(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedger, options?: LedgerUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LedgerUpdateResponse>, LedgerUpdateResponse>>;
     beginUpdateAndWait(resourceGroupName: string, ledgerName: string, confidentialLedger: ConfidentialLedger, options?: LedgerUpdateOptionalParams): Promise<LedgerUpdateResponse>;
     get(resourceGroupName: string, ledgerName: string, options?: LedgerGetOptionalParams): Promise<LedgerGetResponse>;
@@ -191,6 +225,15 @@ export interface Ledger {
     listBySubscription(options?: LedgerListBySubscriptionOptionalParams): PagedAsyncIterableIterator<ConfidentialLedger>;
 }
 
+// @public
+export interface LedgerBackupOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type LedgerBackupResponse = ConfidentialLedgerBackupResponse;
+
 // @public
 export interface LedgerCreateOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
@@ -250,15 +293,28 @@ export interface LedgerProperties {
     readonly identityServiceUri?: string;
     readonly ledgerInternalNamespace?: string;
     readonly ledgerName?: string;
+    ledgerSku?: LedgerSku;
     ledgerType?: LedgerType;
     readonly ledgerUri?: string;
     readonly provisioningState?: ProvisioningState;
     runningState?: RunningState;
 }
 
+// @public
+export interface LedgerRestoreOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type LedgerRestoreResponse = ConfidentialLedgerRestoreResponse;
+
 // @public
 export type LedgerRoleName = string;
 
+// @public
+export type LedgerSku = string;
+
 // @public
 export type LedgerType = string;
 
@@ -276,6 +332,26 @@ export interface ManagedCCF extends TrackedResource {
     properties?: ManagedCCFProperties;
 }
 
+// @public
+export interface ManagedCCFBackup {
+    restoreRegion?: string;
+    uri: string;
+}
+
+// @public
+export type ManagedCCFBackupOperationResponse = ManagedCCFBackupResponse;
+
+// @public
+export interface ManagedCCFBackupOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface ManagedCCFBackupResponse {
+    readonly message?: string;
+}
+
 // @public
 export interface ManagedCCFCreateOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
@@ -336,12 +412,16 @@ export type ManagedCCFListBySubscriptionResponse = ManagedCCFList;
 
 // @public
 export interface ManagedCCFOperations {
+    beginBackup(resourceGroupName: string, appName: string, managedCCF: ManagedCCFBackup, options?: ManagedCCFBackupOptionalParams): Promise<SimplePollerLike<OperationState<ManagedCCFBackupOperationResponse>, ManagedCCFBackupOperationResponse>>;
+    beginBackupAndWait(resourceGroupName: string, appName: string, managedCCF: ManagedCCFBackup, options?: ManagedCCFBackupOptionalParams): Promise<ManagedCCFBackupOperationResponse>;
     beginCreate(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFCreateOptionalParams): Promise<SimplePollerLike<OperationState<ManagedCCFCreateResponse>, ManagedCCFCreateResponse>>;
     beginCreateAndWait(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFCreateOptionalParams): Promise<ManagedCCFCreateResponse>;
     beginDelete(resourceGroupName: string, appName: string, options?: ManagedCCFDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
     beginDeleteAndWait(resourceGroupName: string, appName: string, options?: ManagedCCFDeleteOptionalParams): Promise<void>;
-    beginUpdate(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFUpdateOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
-    beginUpdateAndWait(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFUpdateOptionalParams): Promise<void>;
+    beginRestore(resourceGroupName: string, appName: string, managedCCF: ManagedCCFRestore, options?: ManagedCCFRestoreOptionalParams): Promise<SimplePollerLike<OperationState<ManagedCCFRestoreOperationResponse>, ManagedCCFRestoreOperationResponse>>;
+    beginRestoreAndWait(resourceGroupName: string, appName: string, managedCCF: ManagedCCFRestore, options?: ManagedCCFRestoreOptionalParams): Promise<ManagedCCFRestoreOperationResponse>;
+    beginUpdate(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ManagedCCFUpdateResponse>, ManagedCCFUpdateResponse>>;
+    beginUpdateAndWait(resourceGroupName: string, appName: string, managedCCF: ManagedCCF, options?: ManagedCCFUpdateOptionalParams): Promise<ManagedCCFUpdateResponse>;
     get(resourceGroupName: string, appName: string, options?: ManagedCCFGetOptionalParams): Promise<ManagedCCFGetResponse>;
     listByResourceGroup(resourceGroupName: string, options?: ManagedCCFListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ManagedCCF>;
     listBySubscription(options?: ManagedCCFListBySubscriptionOptionalParams): PagedAsyncIterableIterator<ManagedCCF>;
@@ -356,6 +436,28 @@ export interface ManagedCCFProperties {
     memberIdentityCertificates?: MemberIdentityCertificate[];
     nodeCount?: number;
     readonly provisioningState?: ProvisioningState;
+    runningState?: RunningState;
+}
+
+// @public
+export interface ManagedCCFRestore {
+    fileShareName: string;
+    restoreRegion: string;
+    uri: string;
+}
+
+// @public
+export type ManagedCCFRestoreOperationResponse = ManagedCCFRestoreResponse;
+
+// @public
+export interface ManagedCCFRestoreOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface ManagedCCFRestoreResponse {
+    readonly message?: string;
 }
 
 // @public
@@ -364,6 +466,9 @@ export interface ManagedCCFUpdateOptionalParams extends coreClient.OperationOpti
     updateIntervalInMs?: number;
 }
 
+// @public
+export type ManagedCCFUpdateResponse = ManagedCCF;
+
 // @public
 export interface MemberIdentityCertificate {
     certificate?: string;

package/src/confidentialLedgerClient.ts

@@ -11,18 +11,18 @@ import * as coreRestPipeline from "@azure/core-rest-pipeline";
 import {
   PipelineRequest,
   PipelineResponse,
-  SendRequest
+  SendRequest,
 } from "@azure/core-rest-pipeline";
 import * as coreAuth from "@azure/core-auth";
 import {
   OperationsImpl,
   LedgerImpl,
-  ManagedCCFOperationsImpl
+  ManagedCCFOperationsImpl,
 } from "./operations";
 import {
   Operations,
   Ledger,
-  ManagedCCFOperations
+  ManagedCCFOperations,
 } from "./operationsInterfaces";
 import * as Parameters from "./models/parameters";
 import * as Mappers from "./models/mappers";
@@ -30,7 +30,7 @@ import {
   ConfidentialLedgerClientOptionalParams,
   CheckNameAvailabilityRequest,
   CheckNameAvailabilityOptionalParams,
-  CheckNameAvailabilityOperationResponse
+  CheckNameAvailabilityOperationResponse,
 } from "./models";
 
 export class ConfidentialLedgerClient extends coreClient.ServiceClient {
@@ -47,7 +47,7 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
   constructor(
     credentials: coreAuth.TokenCredential,
     subscriptionId: string,
-    options?: ConfidentialLedgerClientOptionalParams
+    options?: ConfidentialLedgerClientOptionalParams,
   ) {
     if (credentials === undefined) {
       throw new Error("'credentials' cannot be null");
@@ -62,10 +62,10 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
     }
     const defaults: ConfidentialLedgerClientOptionalParams = {
       requestContentType: "application/json; charset=utf-8",
-      credential: credentials
+      credential: credentials,
     };
 
-    const packageDetails = `azsdk-js-arm-confidentialledger/1.3.0-beta.1`;
+    const packageDetails = `azsdk-js-arm-confidentialledger/1.3.0-beta.2`;
     const userAgentPrefix =
       options.userAgentOptions && options.userAgentOptions.userAgentPrefix
         ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
@@ -75,20 +75,21 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
       ...defaults,
       ...options,
       userAgentOptions: {
-        userAgentPrefix
+        userAgentPrefix,
       },
       endpoint:
-        options.endpoint ?? options.baseUri ?? "https://management.azure.com"
+        options.endpoint ?? options.baseUri ?? "https://management.azure.com",
     };
     super(optionsWithDefaults);
 
     let bearerTokenAuthenticationPolicyFound: boolean = false;
     if (options?.pipeline && options.pipeline.getOrderedPolicies().length > 0) {
-      const pipelinePolicies: coreRestPipeline.PipelinePolicy[] = options.pipeline.getOrderedPolicies();
+      const pipelinePolicies: coreRestPipeline.PipelinePolicy[] =
+        options.pipeline.getOrderedPolicies();
       bearerTokenAuthenticationPolicyFound = pipelinePolicies.some(
         (pipelinePolicy) =>
           pipelinePolicy.name ===
-          coreRestPipeline.bearerTokenAuthenticationPolicyName
+          coreRestPipeline.bearerTokenAuthenticationPolicyName,
       );
     }
     if (
@@ -98,7 +99,7 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
       !bearerTokenAuthenticationPolicyFound
     ) {
       this.pipeline.removePolicy({
-        name: coreRestPipeline.bearerTokenAuthenticationPolicyName
+        name: coreRestPipeline.bearerTokenAuthenticationPolicyName,
       });
       this.pipeline.addPolicy(
         coreRestPipeline.bearerTokenAuthenticationPolicy({
@@ -108,9 +109,9 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
             `${optionsWithDefaults.endpoint}/.default`,
           challengeCallbacks: {
             authorizeRequestOnChallenge:
-              coreClient.authorizeRequestOnClaimChallenge
-          }
-        })
+              coreClient.authorizeRequestOnClaimChallenge,
+          },
+        }),
       );
     }
     // Parameter assignments
@@ -118,7 +119,7 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
 
     // Assigning values to Constant parameters
     this.$host = options.$host || "https://management.azure.com";
-    this.apiVersion = options.apiVersion || "2023-01-26-preview";
+    this.apiVersion = options.apiVersion || "2023-06-28-preview";
     this.operations = new OperationsImpl(this);
     this.ledger = new LedgerImpl(this);
     this.managedCCFOperations = new ManagedCCFOperationsImpl(this);
@@ -134,7 +135,7 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
       name: "CustomApiVersionPolicy",
       async sendRequest(
         request: PipelineRequest,
-        next: SendRequest
+        next: SendRequest,
       ): Promise<PipelineResponse> {
         const param = request.url.split("?");
         if (param.length > 1) {
@@ -148,7 +149,7 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
           request.url = param[0] + "?" + newParams.join("&");
         }
         return next(request);
-      }
+      },
     };
     this.pipeline.addPolicy(apiVersionPolicy);
   }
@@ -160,11 +161,11 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
    */
   checkNameAvailability(
     nameAvailabilityRequest: CheckNameAvailabilityRequest,
-    options?: CheckNameAvailabilityOptionalParams
+    options?: CheckNameAvailabilityOptionalParams,
   ): Promise<CheckNameAvailabilityOperationResponse> {
     return this.sendOperationRequest(
       { nameAvailabilityRequest, options },
-      checkNameAvailabilityOperationSpec
+      checkNameAvailabilityOperationSpec,
     );
   }
 
@@ -176,21 +177,20 @@ export class ConfidentialLedgerClient extends coreClient.ServiceClient {
 const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);
 
 const checkNameAvailabilityOperationSpec: coreClient.OperationSpec = {
-  path:
-    "/subscriptions/{subscriptionId}/providers/Microsoft.ConfidentialLedger/checkNameAvailability",
+  path: "/subscriptions/{subscriptionId}/providers/Microsoft.ConfidentialLedger/checkNameAvailability",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.CheckNameAvailabilityResponse
+      bodyMapper: Mappers.CheckNameAvailabilityResponse,
     },
     default: {
-      bodyMapper: Mappers.ErrorResponse
-    }
+      bodyMapper: Mappers.ErrorResponse,
+    },
   },
   requestBody: Parameters.nameAvailabilityRequest,
   queryParameters: [Parameters.apiVersion],
   urlParameters: [Parameters.$host, Parameters.subscriptionId],
   headerParameters: [Parameters.accept, Parameters.contentType],
   mediaType: "json",
-  serializer
+  serializer,
 };

package/src/lroImpl.ts

@@ -28,15 +28,15 @@ export function createLroSpec<T>(inputs: {
     sendInitialRequest: () => sendOperationFn(args, spec),
     sendPollRequest: (
       path: string,
-      options?: { abortSignal?: AbortSignalLike }
+      options?: { abortSignal?: AbortSignalLike },
     ) => {
       const { requestBody, ...restSpec } = spec;
       return sendOperationFn(args, {
         ...restSpec,
         httpMethod: "GET",
         path,
-        abortSignal: options?.abortSignal
+        abortSignal: options?.abortSignal,
       });
-    }
+    },
   };
 }

package/src/models/index.ts

@@ -142,6 +142,8 @@ export interface LedgerProperties {
    * NOTE: This property will not be serialized. It can only be populated by the server.
    */
   readonly provisioningState?: ProvisioningState;
+  /** SKU associated with the ledger */
+  ledgerSku?: LedgerSku;
   /** Array of all AAD based Security Principals. */
   aadBasedSecurityPrincipals?: AADBasedSecurityPrincipal[];
   /** Array of all cert based Security Principals. */
@@ -214,6 +216,42 @@ export interface ConfidentialLedgerList {
   nextLink?: string;
 }
 
+/** Object representing Backup properties of a Confidential Ledger Resource. */
+export interface ConfidentialLedgerBackup {
+  /** The region where the backup of the ledger will eventually be restored to. */
+  restoreRegion?: string;
+  /** SAS URI used to access the backup Fileshare. */
+  uri: string;
+}
+
+/** Object representing the backup response of a Confidential Ledger Resource. */
+export interface ConfidentialLedgerBackupResponse {
+  /**
+   * Response body stating if the ledger is being backed up.
+   * NOTE: This property will not be serialized. It can only be populated by the server.
+   */
+  readonly message?: string;
+}
+
+/** Object representing Restore properties of a Confidential Ledger Resource. */
+export interface ConfidentialLedgerRestore {
+  /** Fileshare where the ledger backup is stored. */
+  fileShareName: string;
+  /** The region the ledger is being restored to. */
+  restoreRegion: string;
+  /** SAS URI used to access the backup fileshare. */
+  uri: string;
+}
+
+/** Object representing the restore response of a Confidential Ledger Resource. */
+export interface ConfidentialLedgerRestoreResponse {
+  /**
+   * Response body stating if the ledger is being restored.
+   * NOTE: This property will not be serialized. It can only be populated by the server.
+   */
+  readonly message?: string;
+}
+
 /** Additional Managed CCF properties. */
 export interface ManagedCCFProperties {
   /**
@@ -235,8 +273,10 @@ export interface ManagedCCFProperties {
   memberIdentityCertificates?: MemberIdentityCertificate[];
   /** Deployment Type of Managed CCF */
   deploymentType?: DeploymentType;
+  /** Object representing RunningState for Managed CCF. */
+  runningState?: RunningState;
   /**
-   * Provisioning state of Ledger Resource
+   * Provisioning state of Managed CCF Resource
    * NOTE: This property will not be serialized. It can only be populated by the server.
    */
   readonly provisioningState?: ProvisioningState;
@@ -270,6 +310,42 @@ export interface ManagedCCFList {
   nextLink?: string;
 }
 
+/** Object representing Backup properties of a Managed CCF Resource. */
+export interface ManagedCCFBackup {
+  /** The region where the backup of the managed CCF resource will eventually be restored to. */
+  restoreRegion?: string;
+  /** SAS URI used to access the backup Fileshare. */
+  uri: string;
+}
+
+/** Object representing the backup response of a Managed CCF Resource. */
+export interface ManagedCCFBackupResponse {
+  /**
+   * Response body stating if the managed CCF resource is being backed up.
+   * NOTE: This property will not be serialized. It can only be populated by the server.
+   */
+  readonly message?: string;
+}
+
+/** Object representing Restore properties of Managed CCF Resource. */
+export interface ManagedCCFRestore {
+  /** Fileshare where the managed CCF resource backup is stored. */
+  fileShareName: string;
+  /** The region the managed CCF resource is being restored to. */
+  restoreRegion: string;
+  /** SAS URI used to access the backup Fileshare. */
+  uri: string;
+}
+
+/** Object representing the restore response of a Managed CCF Resource. */
+export interface ManagedCCFRestoreResponse {
+  /**
+   * Response body stating if the managed CCF resource is being restored.
+   * NOTE: This property will not be serialized. It can only be populated by the server.
+   */
+  readonly message?: string;
+}
+
 /** Tags for Managed CCF Certificates */
 export interface CertificateTags {
   /** Additional tags for Managed CCF Certificates */
@@ -301,7 +377,7 @@ export enum KnownCheckNameAvailabilityReason {
   /** Invalid */
   Invalid = "Invalid",
   /** AlreadyExists */
-  AlreadyExists = "AlreadyExists"
+  AlreadyExists = "AlreadyExists",
 }
 
 /**
@@ -325,7 +401,7 @@ export enum KnownRunningState {
   /** Pausing */
   Pausing = "Pausing",
   /** Resuming */
-  Resuming = "Resuming"
+  Resuming = "Resuming",
 }
 
 /**
@@ -348,7 +424,7 @@ export enum KnownLedgerType {
   /** Public */
   Public = "Public",
   /** Private */
-  Private = "Private"
+  Private = "Private",
 }
 
 /**
@@ -377,7 +453,7 @@ export enum KnownProvisioningState {
   /** Deleting */
   Deleting = "Deleting",
   /** Updating */
-  Updating = "Updating"
+  Updating = "Updating",
 }
 
 /**
@@ -395,6 +471,27 @@ export enum KnownProvisioningState {
  */
 export type ProvisioningState = string;
 
+/** Known values of {@link LedgerSku} that the service accepts. */
+export enum KnownLedgerSku {
+  /** Standard */
+  Standard = "Standard",
+  /** Basic */
+  Basic = "Basic",
+  /** Unknown */
+  Unknown = "Unknown",
+}
+
+/**
+ * Defines values for LedgerSku. \
+ * {@link KnownLedgerSku} can be used interchangeably with LedgerSku,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Standard** \
+ * **Basic** \
+ * **Unknown**
+ */
+export type LedgerSku = string;
+
 /** Known values of {@link LedgerRoleName} that the service accepts. */
 export enum KnownLedgerRoleName {
   /** Reader */
@@ -402,7 +499,7 @@ export enum KnownLedgerRoleName {
   /** Contributor */
   Contributor = "Contributor",
   /** Administrator */
-  Administrator = "Administrator"
+  Administrator = "Administrator",
 }
 
 /**
@@ -425,7 +522,7 @@ export enum KnownCreatedByType {
   /** ManagedIdentity */
   ManagedIdentity = "ManagedIdentity",
   /** Key */
-  Key = "Key"
+  Key = "Key",
 }
 
 /**
@@ -445,7 +542,7 @@ export enum KnownLanguageRuntime {
   /** CPP */
   CPP = "CPP",
   /** JS */
-  JS = "JS"
+  JS = "JS",
 }
 
 /**
@@ -477,7 +574,8 @@ export interface CheckNameAvailabilityOptionalParams
   extends coreClient.OperationOptions {}
 
 /** Contains response data for the checkNameAvailability operation. */
-export type CheckNameAvailabilityOperationResponse = CheckNameAvailabilityResponse;
+export type CheckNameAvailabilityOperationResponse =
+  CheckNameAvailabilityResponse;
 
 /** Optional parameters. */
 export interface LedgerGetOptionalParams extends coreClient.OperationOptions {}
@@ -538,6 +636,30 @@ export interface LedgerListBySubscriptionOptionalParams
 /** Contains response data for the listBySubscription operation. */
 export type LedgerListBySubscriptionResponse = ConfidentialLedgerList;
 
+/** Optional parameters. */
+export interface LedgerBackupOptionalParams
+  extends coreClient.OperationOptions {
+  /** Delay to wait until next poll, in milliseconds. */
+  updateIntervalInMs?: number;
+  /** A serialized poller which can be used to resume an existing paused Long-Running-Operation. */
+  resumeFrom?: string;
+}
+
+/** Contains response data for the backup operation. */
+export type LedgerBackupResponse = ConfidentialLedgerBackupResponse;
+
+/** Optional parameters. */
+export interface LedgerRestoreOptionalParams
+  extends coreClient.OperationOptions {
+  /** Delay to wait until next poll, in milliseconds. */
+  updateIntervalInMs?: number;
+  /** A serialized poller which can be used to resume an existing paused Long-Running-Operation. */
+  resumeFrom?: string;
+}
+
+/** Contains response data for the restore operation. */
+export type LedgerRestoreResponse = ConfidentialLedgerRestoreResponse;
+
 /** Optional parameters. */
 export interface LedgerListByResourceGroupNextOptionalParams
   extends coreClient.OperationOptions {}
@@ -589,6 +711,9 @@ export interface ManagedCCFUpdateOptionalParams
   resumeFrom?: string;
 }
 
+/** Contains response data for the update operation. */
+export type ManagedCCFUpdateResponse = ManagedCCF;
+
 /** Optional parameters. */
 export interface ManagedCCFListByResourceGroupOptionalParams
   extends coreClient.OperationOptions {
@@ -609,6 +734,30 @@ export interface ManagedCCFListBySubscriptionOptionalParams
 /** Contains response data for the listBySubscription operation. */
 export type ManagedCCFListBySubscriptionResponse = ManagedCCFList;
 
+/** Optional parameters. */
+export interface ManagedCCFBackupOptionalParams
+  extends coreClient.OperationOptions {
+  /** Delay to wait until next poll, in milliseconds. */
+  updateIntervalInMs?: number;
+  /** A serialized poller which can be used to resume an existing paused Long-Running-Operation. */
+  resumeFrom?: string;
+}
+
+/** Contains response data for the backup operation. */
+export type ManagedCCFBackupOperationResponse = ManagedCCFBackupResponse;
+
+/** Optional parameters. */
+export interface ManagedCCFRestoreOptionalParams
+  extends coreClient.OperationOptions {
+  /** Delay to wait until next poll, in milliseconds. */
+  updateIntervalInMs?: number;
+  /** A serialized poller which can be used to resume an existing paused Long-Running-Operation. */
+  resumeFrom?: string;
+}
+
+/** Contains response data for the restore operation. */
+export type ManagedCCFRestoreOperationResponse = ManagedCCFRestoreResponse;
+
 /** Optional parameters. */
 export interface ManagedCCFListByResourceGroupNextOptionalParams
   extends coreClient.OperationOptions {}