@azure/arm-keyvault 4.0.0 → 5.0.0

package/dist/esm/models/models.d.ts

@@ -0,0 +1,1826 @@
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
+/** Result of the request to list Storage operations. It contains a list of operations and a URL link to get the next set of results. */
+export interface _OperationListResult {
+    /** List of Storage operations supported by the Storage resource provider. */
+    value: Operation[];
+    /** The URL to get the next set of operations. */
+    nextLink?: string;
+}
+export declare function _operationListResultDeserializer(item: any): _OperationListResult;
+export declare function operationArrayDeserializer(result: Array<Operation>): any[];
+/** Key Vault REST API operation definition. */
+export interface Operation {
+    /** Operation name: {provider}/{resource}/{operation} */
+    name?: string;
+    /** Display metadata associated with the operation. */
+    display?: OperationDisplay;
+    /** The origin of operations. */
+    origin?: string;
+    /** Property to specify whether the action is a data action. */
+    isDataAction?: boolean;
+    /** One property of operation, include metric specifications. */
+    serviceSpecification?: ServiceSpecification;
+}
+export declare function operationDeserializer(item: any): Operation;
+/** Display metadata associated with the operation. */
+export interface OperationDisplay {
+    /** Service provider: Microsoft Key Vault. */
+    provider?: string;
+    /** Resource on which the operation is performed etc. */
+    resource?: string;
+    /** Type of operation: get, read, delete, etc. */
+    operation?: string;
+    /** Description of operation. */
+    description?: string;
+}
+export declare function operationDisplayDeserializer(item: any): OperationDisplay;
+/** Properties of operation, include metric specifications. */
+export interface OperationProperties {
+    /** One property of operation, include metric specifications. */
+    serviceSpecification?: ServiceSpecification;
+}
+export declare function operationPropertiesDeserializer(item: any): OperationProperties;
+/** One property of operation, include log specifications. */
+export interface ServiceSpecification {
+    /** Log specifications of operation. */
+    logSpecifications?: LogSpecification[];
+    /** Metric specifications of operation. */
+    metricSpecifications?: MetricSpecification[];
+}
+export declare function serviceSpecificationDeserializer(item: any): ServiceSpecification;
+export declare function logSpecificationArrayDeserializer(result: Array<LogSpecification>): any[];
+/** Log specification of operation. */
+export interface LogSpecification {
+    /** Name of log specification. */
+    name?: string;
+    /** Display name of log specification. */
+    displayName?: string;
+    /** Blob duration of specification. */
+    blobDuration?: string;
+}
+export declare function logSpecificationDeserializer(item: any): LogSpecification;
+export declare function metricSpecificationArrayDeserializer(result: Array<MetricSpecification>): any[];
+/** Metric specification of operation. */
+export interface MetricSpecification {
+    /** Name of metric specification. */
+    name?: string;
+    /** Display name of metric specification. */
+    displayName?: string;
+    /** Display description of metric specification. */
+    displayDescription?: string;
+    /** The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. */
+    unit?: string;
+    /** The metric aggregation type. Possible values include: 'Average', 'Count', 'Total'. */
+    aggregationType?: string;
+    /** The supported aggregation types for the metrics. */
+    supportedAggregationTypes?: string[];
+    /** The supported time grain types for the metrics. */
+    supportedTimeGrainTypes?: string[];
+    /** The metric lock aggregation type. */
+    lockAggregationType?: string;
+    /** The dimensions of metric */
+    dimensions?: DimensionProperties[];
+    /** Property to specify whether to fill gap with zero. */
+    fillGapWithZero?: boolean;
+    /** The internal metric name. */
+    internalMetricName?: string;
+}
+export declare function metricSpecificationDeserializer(item: any): MetricSpecification;
+export declare function dimensionPropertiesArrayDeserializer(result: Array<DimensionProperties>): any[];
+/** Type of operation: get, read, delete, etc. */
+export interface DimensionProperties {
+    /** Name of dimension. */
+    name?: string;
+    /** Display name of dimension. */
+    displayName?: string;
+    /** Property to specify whether the dimension should be exported for Shoebox. */
+    toBeExportedForShoebox?: boolean;
+}
+export declare function dimensionPropertiesDeserializer(item: any): DimensionProperties;
+/** An error response from Key Vault resource provider */
+export interface CloudError {
+    /** An error response from Key Vault resource provider */
+    error?: CloudErrorBody;
+}
+export declare function cloudErrorDeserializer(item: any): CloudError;
+/** An error response from Key Vault resource provider */
+export interface CloudErrorBody {
+    /** Error code. This is a mnemonic that can be consumed programmatically. */
+    code?: string;
+    /** User friendly error message. The message is typically localized and may vary with service version. */
+    message?: string;
+}
+export declare function cloudErrorBodyDeserializer(item: any): CloudErrorBody;
+/** Resource information with extended details. */
+export interface Vault extends ProxyResource {
+    /** Properties of the vault */
+    properties: VaultProperties;
+    /** Azure location of the key vault resource. */
+    location?: string;
+    /** Tags assigned to the key vault resource. */
+    tags?: Record<string, string>;
+}
+export declare function vaultDeserializer(item: any): Vault;
+/** Properties of the vault */
+export interface VaultProperties {
+    /** The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault. */
+    tenantId: string;
+    /** SKU details */
+    sku: Sku;
+    /** An array of 0 to 1024 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. When `createMode` is set to `recover`, access policies are not required. Otherwise, access policies are required. */
+    accessPolicies?: AccessPolicyEntry[];
+    /** The URI of the vault for performing operations on keys and secrets. */
+    vaultUri?: string;
+    /** The resource id of HSM Pool. */
+    readonly hsmPoolResourceId?: string;
+    /** Property to specify whether Azure Virtual Machines are permitted to retrieve certificates stored as secrets from the key vault. */
+    enabledForDeployment?: boolean;
+    /** Property to specify whether Azure Disk Encryption is permitted to retrieve secrets from the vault and unwrap keys. */
+    enabledForDiskEncryption?: boolean;
+    /** Property to specify whether Azure Resource Manager is permitted to retrieve secrets from the key vault. */
+    enabledForTemplateDeployment?: boolean;
+    /** Property to specify whether the 'soft delete' functionality is enabled for this key vault. If it's not set to any value(true or false) when creating new key vault, it will be set to true by default. Once set to true, it cannot be reverted to false. */
+    enableSoftDelete?: boolean;
+    /** softDelete data retention days. It accepts >=7 and <=90. */
+    softDeleteRetentionInDays?: number;
+    /** Property that controls how data actions are authorized. When true, the key vault will use Role Based Access Control (RBAC) for authorization of data actions, and the access policies specified in vault properties will be  ignored. When false, the key vault will use the access policies specified in vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or not specified, the vault is created with the default value of false. Note that management actions are always authorized with RBAC. */
+    enableRbacAuthorization?: boolean;
+    /** The vault's create mode to indicate whether the vault need to be recovered or not. */
+    createMode?: CreateMode;
+    /** Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The setting is effective only if soft delete is also enabled. Enabling this functionality is irreversible - that is, the property does not accept false as its value. */
+    enablePurgeProtection?: boolean;
+    /** Rules governing the accessibility of the key vault from specific network locations. */
+    networkAcls?: NetworkRuleSet;
+    /** Provisioning state of the vault. */
+    provisioningState?: VaultProvisioningState;
+    /** List of private endpoint connections associated with the key vault. */
+    readonly privateEndpointConnections?: PrivateEndpointConnectionItem[];
+    /** Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, meaning that even if the firewall rules are present we will not honor the rules. */
+    publicNetworkAccess?: string;
+}
+export declare function vaultPropertiesSerializer(item: VaultProperties): any;
+export declare function vaultPropertiesDeserializer(item: any): VaultProperties;
+/** SKU details */
+export interface Sku {
+    /** SKU family name */
+    family: SkuFamily;
+    /** SKU name to specify whether the key vault is a standard vault or a premium vault. */
+    name: SkuName;
+}
+export declare function skuSerializer(item: Sku): any;
+export declare function skuDeserializer(item: any): Sku;
+/** SKU family name */
+export declare enum KnownSkuFamily {
+    /** A */
+    A = "A"
+}
+/**
+ * SKU family name \
+ * {@link KnownSkuFamily} can be used interchangeably with SkuFamily,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **A**
+ */
+export type SkuFamily = string;
+/** SKU name to specify whether the key vault is a standard vault or a premium vault. */
+export type SkuName = "standard" | "premium";
+export declare function accessPolicyEntryArraySerializer(result: Array<AccessPolicyEntry>): any[];
+export declare function accessPolicyEntryArrayDeserializer(result: Array<AccessPolicyEntry>): any[];
+/** An identity that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. */
+export interface AccessPolicyEntry {
+    /** The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault. */
+    tenantId: string;
+    /** The object ID of a user, service principal or security group in the Azure Active Directory tenant for the vault. The object ID must be unique for the list of access policies. */
+    objectId: string;
+    /** Application ID of the client making request on behalf of a principal */
+    applicationId?: string;
+    /** Permissions the identity has for keys, secrets and certificates. */
+    permissions: Permissions;
+}
+export declare function accessPolicyEntrySerializer(item: AccessPolicyEntry): any;
+export declare function accessPolicyEntryDeserializer(item: any): AccessPolicyEntry;
+/** Permissions the identity has for keys, secrets, certificates and storage. */
+export interface Permissions {
+    /** Permissions to keys */
+    keys?: KeyPermissions[];
+    /** Permissions to secrets */
+    secrets?: SecretPermissions[];
+    /** Permissions to certificates */
+    certificates?: CertificatePermissions[];
+    /** Permissions to storage accounts */
+    storage?: StoragePermissions[];
+}
+export declare function permissionsSerializer(item: Permissions): any;
+export declare function permissionsDeserializer(item: any): Permissions;
+/** Known values of {@link KeyPermissions} that the service accepts. */
+export declare enum KnownKeyPermissions {
+    /** all */
+    All = "all",
+    /** encrypt */
+    Encrypt = "encrypt",
+    /** decrypt */
+    Decrypt = "decrypt",
+    /** wrapKey */
+    WrapKey = "wrapKey",
+    /** unwrapKey */
+    UnwrapKey = "unwrapKey",
+    /** sign */
+    Sign = "sign",
+    /** verify */
+    Verify = "verify",
+    /** get */
+    Get = "get",
+    /** list */
+    List = "list",
+    /** create */
+    Create = "create",
+    /** update */
+    Update = "update",
+    /** import */
+    Import = "import",
+    /** delete */
+    Delete = "delete",
+    /** backup */
+    Backup = "backup",
+    /** restore */
+    Restore = "restore",
+    /** recover */
+    Recover = "recover",
+    /** purge */
+    Purge = "purge",
+    /** release */
+    Release = "release",
+    /** rotate */
+    Rotate = "rotate",
+    /** getrotationpolicy */
+    Getrotationpolicy = "getrotationpolicy",
+    /** setrotationpolicy */
+    Setrotationpolicy = "setrotationpolicy"
+}
+/** Type of KeyPermissions */
+export type KeyPermissions = string;
+/** Known values of {@link SecretPermissions} that the service accepts. */
+export declare enum KnownSecretPermissions {
+    /** all */
+    All = "all",
+    /** get */
+    Get = "get",
+    /** list */
+    List = "list",
+    /** set */
+    Set = "set",
+    /** delete */
+    Delete = "delete",
+    /** backup */
+    Backup = "backup",
+    /** restore */
+    Restore = "restore",
+    /** recover */
+    Recover = "recover",
+    /** purge */
+    Purge = "purge"
+}
+/** Type of SecretPermissions */
+export type SecretPermissions = string;
+/** Known values of {@link CertificatePermissions} that the service accepts. */
+export declare enum KnownCertificatePermissions {
+    /** all */
+    All = "all",
+    /** get */
+    Get = "get",
+    /** list */
+    List = "list",
+    /** delete */
+    Delete = "delete",
+    /** create */
+    Create = "create",
+    /** import */
+    Import = "import",
+    /** update */
+    Update = "update",
+    /** managecontacts */
+    Managecontacts = "managecontacts",
+    /** getissuers */
+    Getissuers = "getissuers",
+    /** listissuers */
+    Listissuers = "listissuers",
+    /** setissuers */
+    Setissuers = "setissuers",
+    /** deleteissuers */
+    Deleteissuers = "deleteissuers",
+    /** manageissuers */
+    Manageissuers = "manageissuers",
+    /** recover */
+    Recover = "recover",
+    /** purge */
+    Purge = "purge",
+    /** backup */
+    Backup = "backup",
+    /** restore */
+    Restore = "restore"
+}
+/** Type of CertificatePermissions */
+export type CertificatePermissions = string;
+/** Known values of {@link StoragePermissions} that the service accepts. */
+export declare enum KnownStoragePermissions {
+    /** all */
+    All = "all",
+    /** get */
+    Get = "get",
+    /** list */
+    List = "list",
+    /** delete */
+    Delete = "delete",
+    /** set */
+    Set = "set",
+    /** update */
+    Update = "update",
+    /** regeneratekey */
+    Regeneratekey = "regeneratekey",
+    /** recover */
+    Recover = "recover",
+    /** purge */
+    Purge = "purge",
+    /** backup */
+    Backup = "backup",
+    /** restore */
+    Restore = "restore",
+    /** setsas */
+    Setsas = "setsas",
+    /** listsas */
+    Listsas = "listsas",
+    /** getsas */
+    Getsas = "getsas",
+    /** deletesas */
+    Deletesas = "deletesas"
+}
+/** Type of StoragePermissions */
+export type StoragePermissions = string;
+/** The vault's create mode to indicate whether the vault need to be recovered or not. */
+export type CreateMode = "recover" | "default";
+/** A set of rules governing the network accessibility of a vault. */
+export interface NetworkRuleSet {
+    /** Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'.  If not specified the default is 'AzureServices'. */
+    bypass?: NetworkRuleBypassOptions;
+    /** The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. */
+    defaultAction?: NetworkRuleAction;
+    /** The list of IP address rules. */
+    ipRules?: IPRule[];
+    /** The list of virtual network rules. */
+    virtualNetworkRules?: VirtualNetworkRule[];
+}
+export declare function networkRuleSetSerializer(item: NetworkRuleSet): any;
+export declare function networkRuleSetDeserializer(item: any): NetworkRuleSet;
+/** Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'.  If not specified the default is 'AzureServices'. */
+export declare enum KnownNetworkRuleBypassOptions {
+    /** AzureServices */
+    AzureServices = "AzureServices",
+    /** None */
+    None = "None"
+}
+/**
+ * Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'.  If not specified the default is 'AzureServices'. \
+ * {@link KnownNetworkRuleBypassOptions} can be used interchangeably with NetworkRuleBypassOptions,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AzureServices** \
+ * **None**
+ */
+export type NetworkRuleBypassOptions = string;
+/** The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. */
+export declare enum KnownNetworkRuleAction {
+    /** Allow */
+    Allow = "Allow",
+    /** Deny */
+    Deny = "Deny"
+}
+/**
+ * The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. \
+ * {@link KnownNetworkRuleAction} can be used interchangeably with NetworkRuleAction,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Allow** \
+ * **Deny**
+ */
+export type NetworkRuleAction = string;
+export declare function ipRuleArraySerializer(result: Array<IPRule>): any[];
+export declare function ipRuleArrayDeserializer(result: Array<IPRule>): any[];
+/** A rule governing the accessibility of a vault from a specific ip address or ip range. */
+export interface IPRule {
+    /** An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) or '124.56.78.0/24' (all addresses that start with 124.56.78). */
+    value: string;
+}
+export declare function ipRuleSerializer(item: IPRule): any;
+export declare function ipRuleDeserializer(item: any): IPRule;
+export declare function virtualNetworkRuleArraySerializer(result: Array<VirtualNetworkRule>): any[];
+export declare function virtualNetworkRuleArrayDeserializer(result: Array<VirtualNetworkRule>): any[];
+/** A rule governing the accessibility of a vault from a specific virtual network. */
+export interface VirtualNetworkRule {
+    /** Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. */
+    id: string;
+    /** Property to specify whether NRP will ignore the check if parent subnet has serviceEndpoints configured. */
+    ignoreMissingVnetServiceEndpoint?: boolean;
+}
+export declare function virtualNetworkRuleSerializer(item: VirtualNetworkRule): any;
+export declare function virtualNetworkRuleDeserializer(item: any): VirtualNetworkRule;
+/** Provisioning state of the vault. */
+export declare enum KnownVaultProvisioningState {
+    /** Succeeded */
+    Succeeded = "Succeeded",
+    /** RegisteringDns */
+    RegisteringDns = "RegisteringDns"
+}
+/**
+ * Provisioning state of the vault. \
+ * {@link KnownVaultProvisioningState} can be used interchangeably with VaultProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded** \
+ * **RegisteringDns**
+ */
+export type VaultProvisioningState = string;
+export declare function privateEndpointConnectionItemArrayDeserializer(result: Array<PrivateEndpointConnectionItem>): any[];
+/** Private endpoint connection item. */
+export interface PrivateEndpointConnectionItem {
+    /** Id of private endpoint connection. */
+    id?: string;
+    /** Modified whenever there is a change in the state of private endpoint connection. */
+    etag?: string;
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: PrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function privateEndpointConnectionItemDeserializer(item: any): PrivateEndpointConnectionItem;
+/** Properties of the private endpoint connection resource. */
+export interface PrivateEndpointConnectionProperties {
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: PrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnectionProperties): any;
+export declare function privateEndpointConnectionPropertiesDeserializer(item: any): PrivateEndpointConnectionProperties;
+/** Private endpoint object properties. */
+export interface PrivateEndpoint {
+    /** Full identifier of the private endpoint resource. */
+    readonly id?: string;
+}
+export declare function privateEndpointSerializer(item: PrivateEndpoint): any;
+export declare function privateEndpointDeserializer(item: any): PrivateEndpoint;
+/** An object that represents the approval state of the private link connection. */
+export interface PrivateLinkServiceConnectionState {
+    /** Indicates whether the connection has been approved, rejected or removed by the key vault owner. */
+    status?: PrivateEndpointServiceConnectionStatus;
+    /** The reason for approval or rejection. */
+    description?: string;
+    /** A message indicating if changes on the service provider require any updates on the consumer. */
+    actionsRequired?: ActionsRequired;
+}
+export declare function privateLinkServiceConnectionStateSerializer(item: PrivateLinkServiceConnectionState): any;
+export declare function privateLinkServiceConnectionStateDeserializer(item: any): PrivateLinkServiceConnectionState;
+/** The private endpoint connection status. */
+export declare enum KnownPrivateEndpointServiceConnectionStatus {
+    /** Pending */
+    Pending = "Pending",
+    /** Approved */
+    Approved = "Approved",
+    /** Rejected */
+    Rejected = "Rejected",
+    /** Disconnected */
+    Disconnected = "Disconnected"
+}
+/**
+ * The private endpoint connection status. \
+ * {@link KnownPrivateEndpointServiceConnectionStatus} can be used interchangeably with PrivateEndpointServiceConnectionStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pending** \
+ * **Approved** \
+ * **Rejected** \
+ * **Disconnected**
+ */
+export type PrivateEndpointServiceConnectionStatus = string;
+/** A message indicating if changes on the service provider require any updates on the consumer. */
+export declare enum KnownActionsRequired {
+    /** None */
+    None = "None"
+}
+/**
+ * A message indicating if changes on the service provider require any updates on the consumer. \
+ * {@link KnownActionsRequired} can be used interchangeably with ActionsRequired,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**
+ */
+export type ActionsRequired = string;
+/** The current provisioning state. */
+export declare enum KnownPrivateEndpointConnectionProvisioningState {
+    /** Succeeded */
+    Succeeded = "Succeeded",
+    /** Creating */
+    Creating = "Creating",
+    /** Updating */
+    Updating = "Updating",
+    /** Deleting */
+    Deleting = "Deleting",
+    /** Failed */
+    Failed = "Failed",
+    /** Disconnected */
+    Disconnected = "Disconnected"
+}
+/**
+ * The current provisioning state. \
+ * {@link KnownPrivateEndpointConnectionProvisioningState} can be used interchangeably with PrivateEndpointConnectionProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded** \
+ * **Creating** \
+ * **Updating** \
+ * **Deleting** \
+ * **Failed** \
+ * **Disconnected**
+ */
+export type PrivateEndpointConnectionProvisioningState = string;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnownCreatedByType} can be used interchangeably with CreatedByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** Parameters for creating or updating a vault */
+export interface VaultCreateOrUpdateParameters {
+    /** The supported Azure location where the key vault should be created. */
+    location: string;
+    /** The tags that will be assigned to the key vault. */
+    tags?: Record<string, string>;
+    /** Properties of the vault */
+    properties: VaultProperties;
+}
+export declare function vaultCreateOrUpdateParametersSerializer(item: VaultCreateOrUpdateParameters): any;
+/** Parameters for creating or updating a vault */
+export interface VaultPatchParameters {
+    /** The tags that will be assigned to the key vault. */
+    tags?: Record<string, string>;
+    /** Properties of the vault */
+    properties?: VaultPatchProperties;
+}
+export declare function vaultPatchParametersSerializer(item: VaultPatchParameters): any;
+/** Properties of the vault */
+export interface VaultPatchProperties {
+    /** The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault. */
+    tenantId?: string;
+    /** SKU details */
+    sku?: Sku;
+    /** An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. */
+    accessPolicies?: AccessPolicyEntry[];
+    /** Property to specify whether Azure Virtual Machines are permitted to retrieve certificates stored as secrets from the key vault. */
+    enabledForDeployment?: boolean;
+    /** Property to specify whether Azure Disk Encryption is permitted to retrieve secrets from the vault and unwrap keys. */
+    enabledForDiskEncryption?: boolean;
+    /** Property to specify whether Azure Resource Manager is permitted to retrieve secrets from the key vault. */
+    enabledForTemplateDeployment?: boolean;
+    /** Property to specify whether the 'soft delete' functionality is enabled for this key vault. Once set to true, it cannot be reverted to false. */
+    enableSoftDelete?: boolean;
+    /** Property that controls how data actions are authorized. When true, the key vault will use Role Based Access Control (RBAC) for authorization of data actions, and the access policies specified in vault properties will be  ignored. When false, the key vault will use the access policies specified in vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or not specified, the value of this property will not change. */
+    enableRbacAuthorization?: boolean;
+    /** softDelete data retention days. It accepts >=7 and <=90. */
+    softDeleteRetentionInDays?: number;
+    /** The vault's create mode to indicate whether the vault need to be recovered or not. */
+    createMode?: CreateMode;
+    /** Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The setting is effective only if soft delete is also enabled. Enabling this functionality is irreversible - that is, the property does not accept false as its value. */
+    enablePurgeProtection?: boolean;
+    /** A collection of rules governing the accessibility of the vault from specific network locations. */
+    networkAcls?: NetworkRuleSet;
+    /** Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, meaning that even if the firewall rules are present we will not honor the rules. */
+    publicNetworkAccess?: string;
+}
+export declare function vaultPatchPropertiesSerializer(item: VaultPatchProperties): any;
+/** The response of a Vault list operation. */
+export interface _VaultListResult {
+    /** The Vault items on this page */
+    value: Vault[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _vaultListResultDeserializer(item: any): _VaultListResult;
+export declare function vaultArrayDeserializer(result: Array<Vault>): any[];
+/** Parameters for updating the access policy in a vault */
+export interface VaultAccessPolicyParameters {
+    /** The resource id of the access policy. */
+    readonly id?: string;
+    /** The resource name of the access policy. */
+    readonly name?: string;
+    /** The resource name of the access policy. */
+    readonly type?: string;
+    /** The resource type of the access policy. */
+    readonly location?: string;
+    /** Properties of the access policy */
+    properties: VaultAccessPolicyProperties;
+}
+export declare function vaultAccessPolicyParametersSerializer(item: VaultAccessPolicyParameters): any;
+export declare function vaultAccessPolicyParametersDeserializer(item: any): VaultAccessPolicyParameters;
+/** Properties of the vault access policy */
+export interface VaultAccessPolicyProperties {
+    /** An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. */
+    accessPolicies: AccessPolicyEntry[];
+}
+export declare function vaultAccessPolicyPropertiesSerializer(item: VaultAccessPolicyProperties): any;
+export declare function vaultAccessPolicyPropertiesDeserializer(item: any): VaultAccessPolicyProperties;
+/** Deleted vault information with extended details. */
+export interface DeletedVault extends ProxyResource {
+    /** Properties of the vault */
+    properties?: DeletedVaultProperties;
+}
+export declare function deletedVaultDeserializer(item: any): DeletedVault;
+/** Properties of the deleted vault. */
+export interface DeletedVaultProperties {
+    /** The resource id of the original vault. */
+    readonly vaultId?: string;
+    /** The location of the original vault. */
+    readonly location?: string;
+    /** The deleted date. */
+    readonly deletionDate?: Date;
+    /** The scheduled purged date. */
+    readonly scheduledPurgeDate?: Date;
+    /** Tags of the original vault. */
+    readonly tags?: Record<string, string>;
+    /** Purge protection status of the original vault. */
+    readonly purgeProtectionEnabled?: boolean;
+}
+export declare function deletedVaultPropertiesDeserializer(item: any): DeletedVaultProperties;
+/** The response of a DeletedVault list operation. */
+export interface _DeletedVaultListResult {
+    /** The DeletedVault items on this page */
+    value: DeletedVault[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _deletedVaultListResultDeserializer(item: any): _DeletedVaultListResult;
+export declare function deletedVaultArrayDeserializer(result: Array<DeletedVault>): any[];
+/** The list of vault resources. */
+export interface _ResourceListResult {
+    /** The list of vault resources. */
+    value: TrackedResource[];
+    /** The URL to get the next set of vault resources. */
+    nextLink?: string;
+}
+export declare function _resourceListResultDeserializer(item: any): _ResourceListResult;
+export declare function trackedResourceArrayDeserializer(result: Array<TrackedResource>): any[];
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** The parameters used to check the availability of the vault name. */
+export interface VaultCheckNameAvailabilityParameters {
+    /** The vault name. */
+    name: string;
+    /** The type of resource, Microsoft.KeyVault/vaults */
+    type: "Microsoft.KeyVault/vaults";
+}
+export declare function vaultCheckNameAvailabilityParametersSerializer(item: VaultCheckNameAvailabilityParameters): any;
+/** The CheckNameAvailability operation response. */
+export interface CheckNameAvailabilityResult {
+    /** A boolean value that indicates whether the name is available for you to use. If true, the name is available. If false, the name has already been taken or is invalid and cannot be used. */
+    readonly nameAvailable?: boolean;
+    /** The reason that a vault name could not be used. The Reason element is only returned if NameAvailable is false. */
+    readonly reason?: Reason;
+    /** An error message explaining the Reason value in more detail. */
+    readonly message?: string;
+}
+export declare function checkNameAvailabilityResultDeserializer(item: any): CheckNameAvailabilityResult;
+/** The reason that a vault name could not be used. The Reason element is only returned if NameAvailable is false. */
+export declare enum KnownReason {
+    /** AccountNameInvalid */
+    AccountNameInvalid = "AccountNameInvalid",
+    /** AlreadyExists */
+    AlreadyExists = "AlreadyExists"
+}
+/**
+ * The reason that a vault name could not be used. The Reason element is only returned if NameAvailable is false. \
+ * {@link KnownReason} can be used interchangeably with Reason,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AccountNameInvalid** \
+ * **AlreadyExists**
+ */
+export type Reason = string;
+/** Private endpoint connection resource. */
+export interface PrivateEndpointConnection extends ProxyResource {
+    /** Azure location of the key vault resource. */
+    readonly location?: string;
+    /** Tags assigned to the key vault resource. */
+    readonly tags?: Record<string, string>;
+    /** Modified whenever there is a change in the state of private endpoint connection. */
+    etag?: string;
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: PrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function privateEndpointConnectionSerializer(item: PrivateEndpointConnection): any;
+export declare function privateEndpointConnectionDeserializer(item: any): PrivateEndpointConnection;
+/** The response of a PrivateEndpointConnection list operation. */
+export interface _PrivateEndpointConnectionListResult {
+    /** The PrivateEndpointConnection items on this page */
+    value: PrivateEndpointConnection[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _privateEndpointConnectionListResultDeserializer(item: any): _PrivateEndpointConnectionListResult;
+export declare function privateEndpointConnectionArraySerializer(result: Array<PrivateEndpointConnection>): any[];
+export declare function privateEndpointConnectionArrayDeserializer(result: Array<PrivateEndpointConnection>): any[];
+/** Resource information with extended details. */
+export interface ManagedHsm extends ProxyResource {
+    /** Properties of the managed HSM */
+    properties?: ManagedHsmProperties;
+    /** SKU details */
+    sku?: ManagedHsmSku;
+    /** Managed service identity */
+    identity?: ManagedServiceIdentity;
+    /** The geo-location where the resource lives */
+    location?: string;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+}
+export declare function managedHsmSerializer(item: ManagedHsm): any;
+export declare function managedHsmDeserializer(item: any): ManagedHsm;
+/** Properties of the managed HSM Pool */
+export interface ManagedHsmProperties {
+    /** The Azure Active Directory tenant ID that should be used for authenticating requests to the managed HSM pool. */
+    tenantId?: string;
+    /** Array of initial administrators object ids for this managed hsm pool. */
+    initialAdminObjectIds?: string[];
+    /** The URI of the managed hsm pool for performing operations on keys. */
+    readonly hsmUri?: string;
+    /** Property to specify whether the 'soft delete' functionality is enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and is immutable. */
+    enableSoftDelete?: boolean;
+    /** Soft deleted data retention days. When you delete an HSM or a key, it will remain recoverable for the configured retention period or for a default period of 90 days. It accepts values between 7 and 90. */
+    softDeleteRetentionInDays?: number;
+    /** Property specifying whether protection against purge is enabled for this managed HSM pool. Setting this property to true activates protection against purge for this managed HSM pool and its content - only the Managed HSM service may initiate a hard, irrecoverable deletion. Enabling this functionality is irreversible. */
+    enablePurgeProtection?: boolean;
+    /** The create mode to indicate whether the resource is being created or is being recovered from a deleted resource. */
+    createMode?: CreateMode;
+    /** Resource Status Message. */
+    readonly statusMessage?: string;
+    /** Provisioning state. */
+    readonly provisioningState?: ProvisioningState;
+    /** Rules governing the accessibility of the key vault from specific network locations. */
+    networkAcls?: MhsmNetworkRuleSet;
+    /** List of all regions associated with the managed hsm pool. */
+    regions?: MhsmGeoReplicatedRegion[];
+    /** List of private endpoint connections associated with the managed hsm pool. */
+    readonly privateEndpointConnections?: MhsmPrivateEndpointConnectionItem[];
+    /** Control permission to the managed HSM from public networks. */
+    publicNetworkAccess?: PublicNetworkAccess;
+    /** The scheduled purge date in UTC. */
+    readonly scheduledPurgeDate?: Date;
+    /** Managed HSM security domain properties. */
+    readonly securityDomainProperties?: ManagedHSMSecurityDomainProperties;
+}
+export declare function managedHsmPropertiesSerializer(item: ManagedHsmProperties): any;
+export declare function managedHsmPropertiesDeserializer(item: any): ManagedHsmProperties;
+/** Provisioning state. */
+export declare enum KnownProvisioningState {
+    /** The managed HSM Pool has been full provisioned. */
+    Succeeded = "Succeeded",
+    /** The managed HSM Pool is currently being provisioned. */
+    Provisioning = "Provisioning",
+    /** Provisioning of the managed HSM Pool has failed. */
+    Failed = "Failed",
+    /** The managed HSM Pool is currently being updated. */
+    Updating = "Updating",
+    /** The managed HSM Pool is currently being deleted. */
+    Deleting = "Deleting",
+    /** The managed HSM pool is ready for normal use. */
+    Activated = "Activated",
+    /** The managed HSM pool is waiting for a security domain restore action. */
+    SecurityDomainRestore = "SecurityDomainRestore",
+    /** The managed HSM pool is being restored from full HSM backup. */
+    Restoring = "Restoring"
+}
+/**
+ * Provisioning state. \
+ * {@link KnownProvisioningState} can be used interchangeably with ProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: The managed HSM Pool has been full provisioned. \
+ * **Provisioning**: The managed HSM Pool is currently being provisioned. \
+ * **Failed**: Provisioning of the managed HSM Pool has failed. \
+ * **Updating**: The managed HSM Pool is currently being updated. \
+ * **Deleting**: The managed HSM Pool is currently being deleted. \
+ * **Activated**: The managed HSM pool is ready for normal use. \
+ * **SecurityDomainRestore**: The managed HSM pool is waiting for a security domain restore action. \
+ * **Restoring**: The managed HSM pool is being restored from full HSM backup.
+ */
+export type ProvisioningState = string;
+/** A set of rules governing the network accessibility of a managed hsm pool. */
+export interface MhsmNetworkRuleSet {
+    /** Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'.  If not specified the default is 'AzureServices'. */
+    bypass?: NetworkRuleBypassOptions;
+    /** The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. */
+    defaultAction?: NetworkRuleAction;
+    /** The list of IP address rules. */
+    ipRules?: MhsmipRule[];
+    /** The list of service tags. */
+    serviceTags?: MhsmServiceTagRule[];
+    /** The list of virtual network rules. */
+    virtualNetworkRules?: MhsmVirtualNetworkRule[];
+}
+export declare function mhsmNetworkRuleSetSerializer(item: MhsmNetworkRuleSet): any;
+export declare function mhsmNetworkRuleSetDeserializer(item: any): MhsmNetworkRuleSet;
+export declare function mhsmipRuleArraySerializer(result: Array<MhsmipRule>): any[];
+export declare function mhsmipRuleArrayDeserializer(result: Array<MhsmipRule>): any[];
+/** A rule governing the accessibility of a managed HSM pool from a specific IP address or IP range. */
+export interface MhsmipRule {
+    /** An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) or '124.56.78.0/24' (all addresses that start with 124.56.78). */
+    value: string;
+}
+export declare function mhsmipRuleSerializer(item: MhsmipRule): any;
+export declare function mhsmipRuleDeserializer(item: any): MhsmipRule;
+export declare function mhsmServiceTagRuleArraySerializer(result: Array<MhsmServiceTagRule>): any[];
+export declare function mhsmServiceTagRuleArrayDeserializer(result: Array<MhsmServiceTagRule>): any[];
+/** A rule governing the accessibility of a managed hsm pool from a specific service tags. */
+export interface MhsmServiceTagRule {
+    /** Name of the service tag. */
+    tag: string;
+}
+export declare function mhsmServiceTagRuleSerializer(item: MhsmServiceTagRule): any;
+export declare function mhsmServiceTagRuleDeserializer(item: any): MhsmServiceTagRule;
+export declare function mhsmVirtualNetworkRuleArraySerializer(result: Array<MhsmVirtualNetworkRule>): any[];
+export declare function mhsmVirtualNetworkRuleArrayDeserializer(result: Array<MhsmVirtualNetworkRule>): any[];
+/** A rule governing the accessibility of a managed hsm pool from a specific virtual network. */
+export interface MhsmVirtualNetworkRule {
+    /** Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. */
+    id: string;
+}
+export declare function mhsmVirtualNetworkRuleSerializer(item: MhsmVirtualNetworkRule): any;
+export declare function mhsmVirtualNetworkRuleDeserializer(item: any): MhsmVirtualNetworkRule;
+export declare function mhsmGeoReplicatedRegionArraySerializer(result: Array<MhsmGeoReplicatedRegion>): any[];
+export declare function mhsmGeoReplicatedRegionArrayDeserializer(result: Array<MhsmGeoReplicatedRegion>): any[];
+/** A region that this managed HSM Pool has been extended to. */
+export interface MhsmGeoReplicatedRegion {
+    /** Name of the geo replicated region. */
+    name?: string;
+    /** Provisioning state of the geo replicated region. */
+    readonly provisioningState?: GeoReplicationRegionProvisioningState;
+    /** A boolean value that indicates whether the region is the primary region or a secondary region. */
+    isPrimary?: boolean;
+}
+export declare function mhsmGeoReplicatedRegionSerializer(item: MhsmGeoReplicatedRegion): any;
+export declare function mhsmGeoReplicatedRegionDeserializer(item: any): MhsmGeoReplicatedRegion;
+/** The current provisioning state. */
+export declare enum KnownGeoReplicationRegionProvisioningState {
+    /** Preprovisioning */
+    Preprovisioning = "Preprovisioning",
+    /** Provisioning */
+    Provisioning = "Provisioning",
+    /** Succeeded */
+    Succeeded = "Succeeded",
+    /** Failed */
+    Failed = "Failed",
+    /** Deleting */
+    Deleting = "Deleting",
+    /** Cleanup */
+    Cleanup = "Cleanup"
+}
+/**
+ * The current provisioning state. \
+ * {@link KnownGeoReplicationRegionProvisioningState} can be used interchangeably with GeoReplicationRegionProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Preprovisioning** \
+ * **Provisioning** \
+ * **Succeeded** \
+ * **Failed** \
+ * **Deleting** \
+ * **Cleanup**
+ */
+export type GeoReplicationRegionProvisioningState = string;
+export declare function mhsmPrivateEndpointConnectionItemArrayDeserializer(result: Array<MhsmPrivateEndpointConnectionItem>): any[];
+/** Private endpoint connection item. */
+export interface MhsmPrivateEndpointConnectionItem {
+    /** Id of private endpoint connection. */
+    id?: string;
+    /** Modified whenever there is a change in the state of private endpoint connection. */
+    etag?: string;
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: MhsmPrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: MhsmPrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function mhsmPrivateEndpointConnectionItemDeserializer(item: any): MhsmPrivateEndpointConnectionItem;
+/** Properties of the private endpoint connection resource. */
+export interface MhsmPrivateEndpointConnectionProperties {
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: MhsmPrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: MhsmPrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function mhsmPrivateEndpointConnectionPropertiesSerializer(item: MhsmPrivateEndpointConnectionProperties): any;
+export declare function mhsmPrivateEndpointConnectionPropertiesDeserializer(item: any): MhsmPrivateEndpointConnectionProperties;
+/** Private endpoint object properties. */
+export interface MhsmPrivateEndpoint {
+    /** Full identifier of the private endpoint resource. */
+    readonly id?: string;
+}
+export declare function mhsmPrivateEndpointSerializer(item: MhsmPrivateEndpoint): any;
+export declare function mhsmPrivateEndpointDeserializer(item: any): MhsmPrivateEndpoint;
+/** An object that represents the approval state of the private link connection. */
+export interface MhsmPrivateLinkServiceConnectionState {
+    /** Indicates whether the connection has been approved, rejected or removed by the key vault owner. */
+    status?: PrivateEndpointServiceConnectionStatus;
+    /** The reason for approval or rejection. */
+    description?: string;
+    /** A message indicating if changes on the service provider require any updates on the consumer. */
+    actionsRequired?: ActionsRequired;
+}
+export declare function mhsmPrivateLinkServiceConnectionStateSerializer(item: MhsmPrivateLinkServiceConnectionState): any;
+export declare function mhsmPrivateLinkServiceConnectionStateDeserializer(item: any): MhsmPrivateLinkServiceConnectionState;
+/** Control permission to the managed HSM from public networks. */
+export declare enum KnownPublicNetworkAccess {
+    /** Enabled */
+    Enabled = "Enabled",
+    /** Disabled */
+    Disabled = "Disabled"
+}
+/**
+ * Control permission to the managed HSM from public networks. \
+ * {@link KnownPublicNetworkAccess} can be used interchangeably with PublicNetworkAccess,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled** \
+ * **Disabled**
+ */
+export type PublicNetworkAccess = string;
+/** The security domain properties of the managed hsm. */
+export interface ManagedHSMSecurityDomainProperties {
+    /** Activation Status */
+    readonly activationStatus?: ActivationStatus;
+    /** Activation Status Message. */
+    readonly activationStatusMessage?: string;
+}
+export declare function managedHSMSecurityDomainPropertiesDeserializer(item: any): ManagedHSMSecurityDomainProperties;
+/** Activation Status */
+export declare enum KnownActivationStatus {
+    /** The managed HSM Pool is active. */
+    Active = "Active",
+    /** The managed HSM Pool is not yet activated. */
+    NotActivated = "NotActivated",
+    /** An unknown error occurred while activating managed hsm. */
+    Unknown = "Unknown",
+    /** Failed to activate managed hsm. */
+    Failed = "Failed"
+}
+/**
+ * Activation Status \
+ * {@link KnownActivationStatus} can be used interchangeably with ActivationStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Active**: The managed HSM Pool is active. \
+ * **NotActivated**: The managed HSM Pool is not yet activated. \
+ * **Unknown**: An unknown error occurred while activating managed hsm. \
+ * **Failed**: Failed to activate managed hsm.
+ */
+export type ActivationStatus = string;
+/** SKU details */
+export interface ManagedHsmSku {
+    /** SKU Family of the managed HSM Pool */
+    family: ManagedHsmSkuFamily;
+    /** SKU of the managed HSM Pool */
+    name: ManagedHsmSkuName;
+}
+export declare function managedHsmSkuSerializer(item: ManagedHsmSku): any;
+export declare function managedHsmSkuDeserializer(item: any): ManagedHsmSku;
+/** SKU Family of the managed HSM Pool */
+export declare enum KnownManagedHsmSkuFamily {
+    /** B */
+    B = "B",
+    /** C */
+    C = "C"
+}
+/**
+ * SKU Family of the managed HSM Pool \
+ * {@link KnownManagedHsmSkuFamily} can be used interchangeably with ManagedHsmSkuFamily,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **B** \
+ * **C**
+ */
+export type ManagedHsmSkuFamily = string;
+/** SKU of the managed HSM Pool */
+export type ManagedHsmSkuName = "Standard_B1" | "Custom_B32" | "Custom_B6" | "Custom_C42" | "Custom_C10";
+/** Managed service identity (system assigned and/or user assigned identities) */
+export interface ManagedServiceIdentity {
+    /** The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly principalId?: string;
+    /** The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly tenantId?: string;
+    /** The type of managed identity assigned to this resource. */
+    type: ManagedServiceIdentityType;
+    /** The identities assigned to this resource by the user. */
+    userAssignedIdentities?: Record<string, UserAssignedIdentity>;
+}
+export declare function managedServiceIdentitySerializer(item: ManagedServiceIdentity): any;
+export declare function managedServiceIdentityDeserializer(item: any): ManagedServiceIdentity;
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export declare enum KnownManagedServiceIdentityType {
+    /** No managed identity. */
+    None = "None",
+    /** System assigned managed identity. */
+    SystemAssigned = "SystemAssigned",
+    /** User assigned managed identity. */
+    UserAssigned = "UserAssigned",
+    /** System and user assigned managed identity. */
+    SystemAssignedUserAssigned = "SystemAssigned,UserAssigned"
+}
+/**
+ * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). \
+ * {@link KnownManagedServiceIdentityType} can be used interchangeably with ManagedServiceIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: No managed identity. \
+ * **SystemAssigned**: System assigned managed identity. \
+ * **UserAssigned**: User assigned managed identity. \
+ * **SystemAssigned,UserAssigned**: System and user assigned managed identity.
+ */
+export type ManagedServiceIdentityType = string;
+/** User assigned identity properties */
+export interface UserAssignedIdentity {
+    /** The principal ID of the assigned identity. */
+    readonly principalId?: string;
+    /** The client ID of the assigned identity. */
+    readonly clientId?: string;
+}
+export declare function userAssignedIdentitySerializer(item: UserAssignedIdentity): any;
+export declare function userAssignedIdentityDeserializer(item: any): UserAssignedIdentity;
+/** The error exception. */
+export interface ManagedHsmError {
+    /** The server error. */
+    readonly error?: ErrorModel;
+}
+export declare function managedHsmErrorDeserializer(item: any): ManagedHsmError;
+/** The server error. */
+export interface ErrorModel {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The inner error, contains a more specific error code. */
+    readonly innerError?: ErrorModel;
+}
+export declare function errorDeserializer(item: any): ErrorModel;
+/** The response of a ManagedHsm list operation. */
+export interface _ManagedHsmListResult {
+    /** The ManagedHsm items on this page */
+    value: ManagedHsm[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _managedHsmListResultDeserializer(item: any): _ManagedHsmListResult;
+export declare function managedHsmArraySerializer(result: Array<ManagedHsm>): any[];
+export declare function managedHsmArrayDeserializer(result: Array<ManagedHsm>): any[];
+/** Concrete proxy resource types can be created by aliasing this type using a specific property type. */
+export interface DeletedManagedHsm extends ProxyResource {
+    /** Properties of the deleted managed HSM */
+    properties?: DeletedManagedHsmProperties;
+}
+export declare function deletedManagedHsmDeserializer(item: any): DeletedManagedHsm;
+/** Properties of the deleted managed HSM. */
+export interface DeletedManagedHsmProperties {
+    /** The resource id of the original managed HSM. */
+    readonly mhsmId?: string;
+    /** The location of the original managed HSM. */
+    readonly location?: string;
+    /** The deleted date. */
+    readonly deletionDate?: Date;
+    /** The scheduled purged date. */
+    readonly scheduledPurgeDate?: Date;
+    /** Purge protection status of the original managed HSM. */
+    readonly purgeProtectionEnabled?: boolean;
+    /** Tags of the original managed HSM. */
+    readonly tags?: Record<string, string>;
+}
+export declare function deletedManagedHsmPropertiesDeserializer(item: any): DeletedManagedHsmProperties;
+/** The response of a DeletedManagedHsm list operation. */
+export interface _DeletedManagedHsmListResult {
+    /** The DeletedManagedHsm items on this page */
+    value: DeletedManagedHsm[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _deletedManagedHsmListResultDeserializer(item: any): _DeletedManagedHsmListResult;
+export declare function deletedManagedHsmArrayDeserializer(result: Array<DeletedManagedHsm>): any[];
+/** The parameters used to check the availability of the managed hsm name. */
+export interface CheckMhsmNameAvailabilityParameters {
+    /** The managed hsm name. */
+    name: string;
+}
+export declare function checkMhsmNameAvailabilityParametersSerializer(item: CheckMhsmNameAvailabilityParameters): any;
+/** The CheckMhsmNameAvailability operation response. */
+export interface CheckMhsmNameAvailabilityResult {
+    /** A boolean value that indicates whether the name is available for you to use. If true, the name is available. If false, the name has already been taken or is invalid and cannot be used. */
+    readonly nameAvailable?: boolean;
+    /** The reason that a managed hsm name could not be used. The reason element is only returned if NameAvailable is false. */
+    readonly reason?: Reason;
+    /** An error message explaining the Reason value in more detail. */
+    readonly message?: string;
+}
+export declare function checkMhsmNameAvailabilityResultDeserializer(item: any): CheckMhsmNameAvailabilityResult;
+/** Resource information with extended details. */
+export interface Secret extends ProxyResource {
+    /** Properties of the secret */
+    properties: SecretProperties;
+    /** Azure location of the key vault resource. */
+    readonly location?: string;
+    /** Tags assigned to the key vault resource. */
+    readonly tags?: Record<string, string>;
+}
+export declare function secretDeserializer(item: any): Secret;
+/** Properties of the secret */
+export interface SecretProperties {
+    /** The value of the secret. NOTE: 'value' will never be returned from the service, as APIs using this model are is intended for internal use in ARM deployments. Users should use the data-plane REST service for interaction with vault secrets. */
+    value?: string;
+    /** The content type of the secret. */
+    contentType?: string;
+    /** The attributes of the secret. */
+    attributes?: SecretAttributes;
+    /** The URI to retrieve the current version of the secret. */
+    readonly secretUri?: string;
+    /** The URI to retrieve the specific version of the secret. */
+    readonly secretUriWithVersion?: string;
+}
+export declare function secretPropertiesSerializer(item: SecretProperties): any;
+export declare function secretPropertiesDeserializer(item: any): SecretProperties;
+/** The secret management attributes. */
+export interface SecretAttributes extends Attributes {
+}
+export declare function secretAttributesSerializer(item: SecretAttributes): any;
+export declare function secretAttributesDeserializer(item: any): SecretAttributes;
+/** The object attributes managed by the KeyVault service. */
+export interface Attributes {
+    /** Determines whether the object is enabled. */
+    enabled?: boolean;
+    /** Not before date in seconds since 1970-01-01T00:00:00Z. */
+    notBefore?: Date;
+    /** Expiry date in seconds since 1970-01-01T00:00:00Z. */
+    expires?: Date;
+    /** Creation time in seconds since 1970-01-01T00:00:00Z. */
+    readonly created?: Date;
+    /** Last updated time in seconds since 1970-01-01T00:00:00Z. */
+    readonly updated?: Date;
+}
+export declare function attributesSerializer(item: Attributes): any;
+export declare function attributesDeserializer(item: any): Attributes;
+/** Parameters for creating or updating a secret */
+export interface SecretCreateOrUpdateParameters {
+    /** The tags that will be assigned to the secret. */
+    tags?: Record<string, string>;
+    /** Properties of the secret */
+    properties: SecretProperties;
+}
+export declare function secretCreateOrUpdateParametersSerializer(item: SecretCreateOrUpdateParameters): any;
+/** Parameters for patching a secret */
+export interface SecretPatchParameters {
+    /** The tags that will be assigned to the secret. */
+    tags?: Record<string, string>;
+    /** Properties of the secret */
+    properties?: SecretPatchProperties;
+}
+export declare function secretPatchParametersSerializer(item: SecretPatchParameters): any;
+/** Properties of the secret */
+export interface SecretPatchProperties {
+    /** The value of the secret. */
+    value?: string;
+    /** The content type of the secret. */
+    contentType?: string;
+    /** The attributes of the secret. */
+    attributes?: SecretAttributes;
+}
+export declare function secretPatchPropertiesSerializer(item: SecretPatchProperties): any;
+/** The response of a Secret list operation. */
+export interface _SecretListResult {
+    /** The Secret items on this page */
+    value: Secret[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _secretListResultDeserializer(item: any): _SecretListResult;
+export declare function secretArrayDeserializer(result: Array<Secret>): any[];
+/** The key resource. */
+export interface Key extends ProxyResource {
+    /** The supported Azure location where the managed HSM Pool should be created. */
+    readonly location?: string;
+    /** Resource tags */
+    readonly tags?: Record<string, string>;
+    /** The attributes of the key. */
+    attributes?: KeyAttributes;
+    /** The type of the key. For valid values, see JsonWebKeyType. */
+    kty?: JsonWebKeyType;
+    keyOps?: JsonWebKeyOperation[];
+    /** The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys default to 4096. */
+    keySize?: number;
+    /** The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 */
+    curveName?: JsonWebKeyCurveName;
+    /** The URI to retrieve the current version of the key. */
+    readonly keyUri?: string;
+    /** The URI to retrieve the specific version of the key. */
+    readonly keyUriWithVersion?: string;
+    /** Key rotation policy in response. It will be used for both output and input. Omitted if empty */
+    rotationPolicy?: RotationPolicy;
+    /** Key release policy in response. It will be used for both output and input. Omitted if empty */
+    releasePolicy?: KeyReleasePolicy;
+}
+export declare function keyDeserializer(item: any): Key;
+/** The properties of the key. */
+export interface KeyProperties {
+    /** The attributes of the key. */
+    attributes?: KeyAttributes;
+    /** The type of the key. For valid values, see JsonWebKeyType. */
+    kty?: JsonWebKeyType;
+    keyOps?: JsonWebKeyOperation[];
+    /** The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys default to 4096. */
+    keySize?: number;
+    /** The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 */
+    curveName?: JsonWebKeyCurveName;
+    /** The URI to retrieve the current version of the key. */
+    readonly keyUri?: string;
+    /** The URI to retrieve the specific version of the key. */
+    readonly keyUriWithVersion?: string;
+    /** Key rotation policy in response. It will be used for both output and input. Omitted if empty */
+    rotationPolicy?: RotationPolicy;
+    /** Key release policy in response. It will be used for both output and input. Omitted if empty */
+    releasePolicy?: KeyReleasePolicy;
+}
+export declare function keyPropertiesSerializer(item: KeyProperties): any;
+export declare function keyPropertiesDeserializer(item: any): KeyProperties;
+/** The object attributes managed by the Azure Key Vault service. */
+export interface KeyAttributes {
+    /** Determines whether or not the object is enabled. */
+    enabled?: boolean;
+    /** Not before date in seconds since 1970-01-01T00:00:00Z. */
+    notBefore?: number;
+    /** Expiry date in seconds since 1970-01-01T00:00:00Z. */
+    expires?: number;
+    /** Creation time in seconds since 1970-01-01T00:00:00Z. */
+    readonly created?: number;
+    /** Last updated time in seconds since 1970-01-01T00:00:00Z. */
+    readonly updated?: number;
+    /** The deletion recovery level currently in effect for the object. If it contains 'Purgeable', then the object can be permanently deleted by a privileged user; otherwise, only the system can purge the object at the end of the retention interval. */
+    readonly recoveryLevel?: DeletionRecoveryLevel;
+    /** Indicates if the private key can be exported. */
+    exportable?: boolean;
+}
+export declare function keyAttributesSerializer(item: KeyAttributes): any;
+export declare function keyAttributesDeserializer(item: any): KeyAttributes;
+/** The deletion recovery level currently in effect for the object. If it contains 'Purgeable', then the object can be permanently deleted by a privileged user; otherwise, only the system can purge the object at the end of the retention interval. */
+export declare enum KnownDeletionRecoveryLevel {
+    /** Purgeable */
+    Purgeable = "Purgeable",
+    /** Recoverable+Purgeable */
+    RecoverablePurgeable = "Recoverable+Purgeable",
+    /** Recoverable */
+    Recoverable = "Recoverable",
+    /** Recoverable+ProtectedSubscription */
+    RecoverableProtectedSubscription = "Recoverable+ProtectedSubscription"
+}
+/**
+ * The deletion recovery level currently in effect for the object. If it contains 'Purgeable', then the object can be permanently deleted by a privileged user; otherwise, only the system can purge the object at the end of the retention interval. \
+ * {@link KnownDeletionRecoveryLevel} can be used interchangeably with DeletionRecoveryLevel,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Purgeable** \
+ * **Recoverable+Purgeable** \
+ * **Recoverable** \
+ * **Recoverable+ProtectedSubscription**
+ */
+export type DeletionRecoveryLevel = string;
+/** The type of the key. For valid values, see JsonWebKeyType. */
+export declare enum KnownJsonWebKeyType {
+    /** EC */
+    EC = "EC",
+    /** EC-HSM */
+    ECHSM = "EC-HSM",
+    /** RSA */
+    RSA = "RSA",
+    /** RSA-HSM */
+    RSAHSM = "RSA-HSM"
+}
+/**
+ * The type of the key. For valid values, see JsonWebKeyType. \
+ * {@link KnownJsonWebKeyType} can be used interchangeably with JsonWebKeyType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **EC** \
+ * **EC-HSM** \
+ * **RSA** \
+ * **RSA-HSM**
+ */
+export type JsonWebKeyType = string;
+/** The permitted JSON web key operations of the key. For more information, see JsonWebKeyOperation. */
+export declare enum KnownJsonWebKeyOperation {
+    /** encrypt */
+    Encrypt = "encrypt",
+    /** decrypt */
+    Decrypt = "decrypt",
+    /** sign */
+    Sign = "sign",
+    /** verify */
+    Verify = "verify",
+    /** wrapKey */
+    WrapKey = "wrapKey",
+    /** unwrapKey */
+    UnwrapKey = "unwrapKey",
+    /** import */
+    Import = "import",
+    /** release */
+    Release = "release"
+}
+/**
+ * The permitted JSON web key operations of the key. For more information, see JsonWebKeyOperation. \
+ * {@link KnownJsonWebKeyOperation} can be used interchangeably with JsonWebKeyOperation,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **encrypt** \
+ * **decrypt** \
+ * **sign** \
+ * **verify** \
+ * **wrapKey** \
+ * **unwrapKey** \
+ * **import** \
+ * **release**
+ */
+export type JsonWebKeyOperation = string;
+/** The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 */
+export declare enum KnownJsonWebKeyCurveName {
+    /** P-256 */
+    P256 = "P-256",
+    /** P-384 */
+    P384 = "P-384",
+    /** P-521 */
+    P521 = "P-521",
+    /** P-256K */
+    P256K = "P-256K"
+}
+/**
+ * The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 \
+ * {@link KnownJsonWebKeyCurveName} can be used interchangeably with JsonWebKeyCurveName,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **P-256** \
+ * **P-384** \
+ * **P-521** \
+ * **P-256K**
+ */
+export type JsonWebKeyCurveName = string;
+/** model interface RotationPolicy */
+export interface RotationPolicy {
+    /** The attributes of key rotation policy. */
+    attributes?: KeyRotationPolicyAttributes;
+    /** The lifetimeActions for key rotation action. */
+    lifetimeActions?: LifetimeAction[];
+}
+export declare function rotationPolicySerializer(item: RotationPolicy): any;
+export declare function rotationPolicyDeserializer(item: any): RotationPolicy;
+/** model interface KeyRotationPolicyAttributes */
+export interface KeyRotationPolicyAttributes {
+    /** Creation time in seconds since 1970-01-01T00:00:00Z. */
+    readonly created?: number;
+    /** Last updated time in seconds since 1970-01-01T00:00:00Z. */
+    readonly updated?: number;
+    /** The expiration time for the new key version. It should be in ISO8601 format. Eg: 'P90D', 'P1Y'. */
+    expiryTime?: string;
+}
+export declare function keyRotationPolicyAttributesSerializer(item: KeyRotationPolicyAttributes): any;
+export declare function keyRotationPolicyAttributesDeserializer(item: any): KeyRotationPolicyAttributes;
+export declare function lifetimeActionArraySerializer(result: Array<LifetimeAction>): any[];
+export declare function lifetimeActionArrayDeserializer(result: Array<LifetimeAction>): any[];
+/** model interface LifetimeAction */
+export interface LifetimeAction {
+    /** The trigger of key rotation policy lifetimeAction. */
+    trigger?: Trigger;
+    /** The action of key rotation policy lifetimeAction. */
+    action?: Action;
+}
+export declare function lifetimeActionSerializer(item: LifetimeAction): any;
+export declare function lifetimeActionDeserializer(item: any): LifetimeAction;
+/** model interface Trigger */
+export interface Trigger {
+    /** The time duration after key creation to rotate the key. It only applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. */
+    timeAfterCreate?: string;
+    /** The time duration before key expiring to rotate or notify. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. */
+    timeBeforeExpiry?: string;
+}
+export declare function triggerSerializer(item: Trigger): any;
+export declare function triggerDeserializer(item: any): Trigger;
+/** model interface Action */
+export interface Action {
+    /** The type of action. */
+    type?: KeyRotationPolicyActionType;
+}
+export declare function actionSerializer(item: Action): any;
+export declare function actionDeserializer(item: any): Action;
+/** The type of action. */
+export type KeyRotationPolicyActionType = "rotate" | "notify";
+/** model interface KeyReleasePolicy */
+export interface KeyReleasePolicy {
+    /** Content type and version of key release policy */
+    contentType?: string;
+    /** Blob encoding the policy rules under which the key can be released. */
+    data?: Uint8Array;
+}
+export declare function keyReleasePolicySerializer(item: KeyReleasePolicy): any;
+export declare function keyReleasePolicyDeserializer(item: any): KeyReleasePolicy;
+/** The parameters used to create a key. */
+export interface KeyCreateParameters {
+    /** The tags that will be assigned to the key. */
+    tags?: Record<string, string>;
+    /** The properties of the key to be created. */
+    properties: KeyProperties;
+}
+export declare function keyCreateParametersSerializer(item: KeyCreateParameters): any;
+/** The response of a Key list operation. */
+export interface _KeyListResult {
+    /** The Key items on this page */
+    value: Key[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _keyListResultDeserializer(item: any): _KeyListResult;
+export declare function keyArrayDeserializer(result: Array<Key>): any[];
+/** The key resource. */
+export interface ManagedHsmKey extends ProxyResource {
+    /** Resource tags */
+    tags?: Record<string, string>;
+    /** The attributes of the key. */
+    attributes?: ManagedHsmKeyAttributes;
+    /** The type of the key. For valid values, see JsonWebKeyType. */
+    kty?: JsonWebKeyType;
+    keyOps?: JsonWebKeyOperation[];
+    /** The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys default to 4096. */
+    keySize?: number;
+    /** The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 */
+    curveName?: JsonWebKeyCurveName;
+    /** The URI to retrieve the current version of the key. */
+    readonly keyUri?: string;
+    /** The URI to retrieve the specific version of the key. */
+    readonly keyUriWithVersion?: string;
+    /** Key rotation policy in response. It will be used for both output and input. Omitted if empty */
+    rotationPolicy?: ManagedHsmRotationPolicy;
+    /** Key release policy in response. It will be used for both output and input. Omitted if empty */
+    releasePolicy?: ManagedHsmKeyReleasePolicy;
+}
+export declare function managedHsmKeyDeserializer(item: any): ManagedHsmKey;
+/** The properties of the key. */
+export interface ManagedHsmKeyProperties {
+    /** The attributes of the key. */
+    attributes?: ManagedHsmKeyAttributes;
+    /** The type of the key. For valid values, see JsonWebKeyType. */
+    kty?: JsonWebKeyType;
+    keyOps?: JsonWebKeyOperation[];
+    /** The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys default to 4096. */
+    keySize?: number;
+    /** The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM keys is P-256 */
+    curveName?: JsonWebKeyCurveName;
+    /** The URI to retrieve the current version of the key. */
+    readonly keyUri?: string;
+    /** The URI to retrieve the specific version of the key. */
+    readonly keyUriWithVersion?: string;
+    /** Key rotation policy in response. It will be used for both output and input. Omitted if empty */
+    rotationPolicy?: ManagedHsmRotationPolicy;
+    /** Key release policy in response. It will be used for both output and input. Omitted if empty */
+    releasePolicy?: ManagedHsmKeyReleasePolicy;
+}
+export declare function managedHsmKeyPropertiesSerializer(item: ManagedHsmKeyProperties): any;
+export declare function managedHsmKeyPropertiesDeserializer(item: any): ManagedHsmKeyProperties;
+/** The object attributes managed by the Azure Key Vault service. */
+export interface ManagedHsmKeyAttributes {
+    /** Determines whether or not the object is enabled. */
+    enabled?: boolean;
+    /** Not before date in seconds since 1970-01-01T00:00:00Z. */
+    notBefore?: number;
+    /** Expiry date in seconds since 1970-01-01T00:00:00Z. */
+    expires?: number;
+    /** Creation time in seconds since 1970-01-01T00:00:00Z. */
+    readonly created?: number;
+    /** Last updated time in seconds since 1970-01-01T00:00:00Z. */
+    readonly updated?: number;
+    /** The deletion recovery level currently in effect for the object. If it contains 'Purgeable', then the object can be permanently deleted by a privileged user; otherwise, only the system can purge the object at the end of the retention interval. */
+    readonly recoveryLevel?: DeletionRecoveryLevel;
+    /** Indicates if the private key can be exported. */
+    exportable?: boolean;
+}
+export declare function managedHsmKeyAttributesSerializer(item: ManagedHsmKeyAttributes): any;
+export declare function managedHsmKeyAttributesDeserializer(item: any): ManagedHsmKeyAttributes;
+/** model interface ManagedHsmRotationPolicy */
+export interface ManagedHsmRotationPolicy {
+    /** The attributes of key rotation policy. */
+    attributes?: ManagedHsmKeyRotationPolicyAttributes;
+    /** The lifetimeActions for key rotation action. */
+    lifetimeActions?: ManagedHsmLifetimeAction[];
+}
+export declare function managedHsmRotationPolicySerializer(item: ManagedHsmRotationPolicy): any;
+export declare function managedHsmRotationPolicyDeserializer(item: any): ManagedHsmRotationPolicy;
+/** model interface ManagedHsmKeyRotationPolicyAttributes */
+export interface ManagedHsmKeyRotationPolicyAttributes {
+    /** Creation time in seconds since 1970-01-01T00:00:00Z. */
+    readonly created?: number;
+    /** Last updated time in seconds since 1970-01-01T00:00:00Z. */
+    readonly updated?: number;
+    /** The expiration time for the new key version. It should be in ISO8601 format. Eg: 'P90D', 'P1Y'. */
+    expiryTime?: string;
+}
+export declare function managedHsmKeyRotationPolicyAttributesSerializer(item: ManagedHsmKeyRotationPolicyAttributes): any;
+export declare function managedHsmKeyRotationPolicyAttributesDeserializer(item: any): ManagedHsmKeyRotationPolicyAttributes;
+export declare function managedHsmLifetimeActionArraySerializer(result: Array<ManagedHsmLifetimeAction>): any[];
+export declare function managedHsmLifetimeActionArrayDeserializer(result: Array<ManagedHsmLifetimeAction>): any[];
+/** model interface ManagedHsmLifetimeAction */
+export interface ManagedHsmLifetimeAction {
+    /** The trigger of key rotation policy lifetimeAction. */
+    trigger?: ManagedHsmTrigger;
+    /** The action of key rotation policy lifetimeAction. */
+    action?: ManagedHsmAction;
+}
+export declare function managedHsmLifetimeActionSerializer(item: ManagedHsmLifetimeAction): any;
+export declare function managedHsmLifetimeActionDeserializer(item: any): ManagedHsmLifetimeAction;
+/** model interface ManagedHsmTrigger */
+export interface ManagedHsmTrigger {
+    /** The time duration after key creation to rotate the key. It only applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. */
+    timeAfterCreate?: string;
+    /** The time duration before key expiring to rotate or notify. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. */
+    timeBeforeExpiry?: string;
+}
+export declare function managedHsmTriggerSerializer(item: ManagedHsmTrigger): any;
+export declare function managedHsmTriggerDeserializer(item: any): ManagedHsmTrigger;
+/** model interface ManagedHsmAction */
+export interface ManagedHsmAction {
+    /** The type of action. */
+    type?: KeyRotationPolicyActionType;
+}
+export declare function managedHsmActionSerializer(item: ManagedHsmAction): any;
+export declare function managedHsmActionDeserializer(item: any): ManagedHsmAction;
+/** model interface ManagedHsmKeyReleasePolicy */
+export interface ManagedHsmKeyReleasePolicy {
+    /** Content type and version of key release policy */
+    contentType?: string;
+    /** Blob encoding the policy rules under which the key can be released. */
+    data?: Uint8Array;
+}
+export declare function managedHsmKeyReleasePolicySerializer(item: ManagedHsmKeyReleasePolicy): any;
+export declare function managedHsmKeyReleasePolicyDeserializer(item: any): ManagedHsmKeyReleasePolicy;
+/** The parameters used to create a key. */
+export interface ManagedHsmKeyCreateParameters {
+    /** The tags that will be assigned to the key. */
+    tags?: Record<string, string>;
+    /** The properties of the key to be created. */
+    properties: ManagedHsmKeyProperties;
+}
+export declare function managedHsmKeyCreateParametersSerializer(item: ManagedHsmKeyCreateParameters): any;
+/** The response of a ManagedHsmKey list operation. */
+export interface _ManagedHsmKeyListResult {
+    /** The ManagedHsmKey items on this page */
+    value: ManagedHsmKey[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _managedHsmKeyListResultDeserializer(item: any): _ManagedHsmKeyListResult;
+export declare function managedHsmKeyArrayDeserializer(result: Array<ManagedHsmKey>): any[];
+/** A list of private link resources */
+export interface PrivateLinkResourceListResult {
+    /** Array of private link resources */
+    value?: PrivateLinkResource[];
+}
+export declare function privateLinkResourceListResultDeserializer(item: any): PrivateLinkResourceListResult;
+export declare function privateLinkResourceArrayDeserializer(result: Array<PrivateLinkResource>): any[];
+/** A private link resource */
+export interface PrivateLinkResource extends ProxyResource {
+    /** Azure location of the key vault resource. */
+    readonly location?: string;
+    /** Tags assigned to the key vault resource. */
+    readonly tags?: Record<string, string>;
+    /** Group identifier of private link resource. */
+    readonly groupId?: string;
+    /** Required member names of private link resource. */
+    readonly requiredMembers?: string[];
+    /** Required DNS zone names of the the private link resource. */
+    requiredZoneNames?: string[];
+}
+export declare function privateLinkResourceDeserializer(item: any): PrivateLinkResource;
+/** Properties of a private link resource. */
+export interface PrivateLinkResourceProperties {
+    /** Group identifier of private link resource. */
+    readonly groupId?: string;
+    /** Required member names of private link resource. */
+    readonly requiredMembers?: string[];
+    /** Required DNS zone names of the the private link resource. */
+    requiredZoneNames?: string[];
+}
+export declare function privateLinkResourcePropertiesDeserializer(item: any): PrivateLinkResourceProperties;
+/** A list of private link resources */
+export interface MhsmPrivateLinkResourceListResult {
+    /** Array of private link resources */
+    value?: MhsmPrivateLinkResource[];
+}
+export declare function mhsmPrivateLinkResourceListResultDeserializer(item: any): MhsmPrivateLinkResourceListResult;
+export declare function mhsmPrivateLinkResourceArrayDeserializer(result: Array<MhsmPrivateLinkResource>): any[];
+/** A private link resource */
+export interface MhsmPrivateLinkResource extends TrackedResource {
+    /** SKU details */
+    sku?: ManagedHsmSku;
+    /** Managed service identity (system assigned and/or user assigned identities) */
+    identity?: ManagedServiceIdentity;
+    /** Group identifier of private link resource. */
+    readonly groupId?: string;
+    /** Required member names of private link resource. */
+    readonly requiredMembers?: string[];
+    /** Required DNS zone names of the the private link resource. */
+    requiredZoneNames?: string[];
+}
+export declare function mhsmPrivateLinkResourceDeserializer(item: any): MhsmPrivateLinkResource;
+/** Properties of a private link resource. */
+export interface MhsmPrivateLinkResourceProperties {
+    /** Group identifier of private link resource. */
+    readonly groupId?: string;
+    /** Required member names of private link resource. */
+    readonly requiredMembers?: string[];
+    /** Required DNS zone names of the the private link resource. */
+    requiredZoneNames?: string[];
+}
+export declare function mhsmPrivateLinkResourcePropertiesDeserializer(item: any): MhsmPrivateLinkResourceProperties;
+/** List of regions associated with a managed HSM Pools */
+export interface _MhsmRegionsListResult {
+    /** The MhsmGeoReplicatedRegion items on this page */
+    value: MhsmGeoReplicatedRegion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _mhsmRegionsListResultDeserializer(item: any): _MhsmRegionsListResult;
+/** Private endpoint connection resource. */
+export interface MhsmPrivateEndpointConnection extends ProxyResource {
+    /** SKU details */
+    sku?: ManagedHsmSku;
+    /** Managed service identity */
+    identity?: ManagedServiceIdentity;
+    /** Modified whenever there is a change in the state of private endpoint connection. */
+    etag?: string;
+    /** The geo-location where the resource lives */
+    location?: string;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** Properties of the private endpoint object. */
+    privateEndpoint?: MhsmPrivateEndpoint;
+    /** Approval state of the private link connection. */
+    privateLinkServiceConnectionState?: MhsmPrivateLinkServiceConnectionState;
+    /** Provisioning state of the private endpoint connection. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function mhsmPrivateEndpointConnectionSerializer(item: MhsmPrivateEndpointConnection): any;
+export declare function mhsmPrivateEndpointConnectionDeserializer(item: any): MhsmPrivateEndpointConnection;
+/** List of private endpoint connections associated with a managed HSM Pools */
+export interface _MhsmPrivateEndpointConnectionsListResult {
+    /** The MhsmPrivateEndpointConnection items on this page */
+    value: MhsmPrivateEndpointConnection[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _mhsmPrivateEndpointConnectionsListResultDeserializer(item: any): _MhsmPrivateEndpointConnectionsListResult;
+export declare function mhsmPrivateEndpointConnectionArraySerializer(result: Array<MhsmPrivateEndpointConnection>): any[];
+export declare function mhsmPrivateEndpointConnectionArrayDeserializer(result: Array<MhsmPrivateEndpointConnection>): any[];
+/** Type of AccessPolicyUpdateKind */
+export type AccessPolicyUpdateKind = "add" | "replace" | "remove";
+/** The available API versions. */
+export declare enum KnownVersions {
+    /** The 2025-05-01 API version. */
+    V20250501 = "2025-05-01",
+    /** The 2026-02-01 API version. */
+    V20260201 = "2026-02-01"
+}
+export declare function _operationOperationPropertiesDeserializer(item: any): {
+    serviceSpecification: any;
+};
+export declare function _privateEndpointConnectionItemPropertiesSerializer(item: PrivateEndpointConnectionItem): any;
+export declare function _privateEndpointConnectionItemPropertiesDeserializer(item: any): {
+    privateEndpoint: any;
+    privateLinkServiceConnectionState: any;
+    provisioningState: any;
+};
+export declare function _privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnection): any;
+export declare function _privateEndpointConnectionPropertiesDeserializer(item: any): {
+    privateEndpoint: any;
+    privateLinkServiceConnectionState: any;
+    provisioningState: any;
+};
+export declare function _mhsmPrivateEndpointConnectionItemPropertiesSerializer(item: MhsmPrivateEndpointConnectionItem): any;
+export declare function _mhsmPrivateEndpointConnectionItemPropertiesDeserializer(item: any): {
+    privateEndpoint: any;
+    privateLinkServiceConnectionState: any;
+    provisioningState: any;
+};
+export declare function _keyPropertiesSerializer(item: Key): any;
+export declare function _keyPropertiesDeserializer(item: any): {
+    attributes: any;
+    kty: any;
+    keyOps: any;
+    keySize: any;
+    curveName: any;
+    keyUri: any;
+    keyUriWithVersion: any;
+    rotationPolicy: any;
+    releasePolicy: any;
+};
+export declare function _managedHsmKeyPropertiesSerializer(item: ManagedHsmKey): any;
+export declare function _managedHsmKeyPropertiesDeserializer(item: any): {
+    attributes: any;
+    kty: any;
+    keyOps: any;
+    keySize: any;
+    curveName: any;
+    keyUri: any;
+    keyUriWithVersion: any;
+    rotationPolicy: any;
+    releasePolicy: any;
+};
+export declare function _privateLinkResourcePropertiesDeserializer(item: any): {
+    groupId: any;
+    requiredMembers: any;
+    requiredZoneNames: any;
+};
+export declare function _mhsmPrivateLinkResourcePropertiesDeserializer(item: any): {
+    groupId: any;
+    requiredMembers: any;
+    requiredZoneNames: any;
+};
+export declare function _mhsmPrivateEndpointConnectionPropertiesSerializer(item: MhsmPrivateEndpointConnection): any;
+export declare function _mhsmPrivateEndpointConnectionPropertiesDeserializer(item: any): {
+    privateEndpoint: any;
+    privateLinkServiceConnectionState: any;
+    provisioningState: any;
+};
+//# sourceMappingURL=models.d.ts.map