var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var parameters_exports = {};
__export(parameters_exports, {
  accept: () => accept,
  accept1: () => accept1,
  accept2: () => accept2,
  access: () => access,
  accessTierIfModifiedSince: () => accessTierIfModifiedSince,
  accessTierIfUnmodifiedSince: () => accessTierIfUnmodifiedSince,
  action: () => action,
  action1: () => action1,
  action2: () => action2,
  action3: () => action3,
  action4: () => action4,
  appendPosition: () => appendPosition,
  blobCacheControl: () => blobCacheControl,
  blobContentDisposition: () => blobContentDisposition,
  blobContentEncoding: () => blobContentEncoding,
  blobContentLanguage: () => blobContentLanguage,
  blobContentLength: () => blobContentLength,
  blobContentMD5: () => blobContentMD5,
  blobContentType: () => blobContentType,
  blobDeleteType: () => blobDeleteType,
  blobSequenceNumber: () => blobSequenceNumber,
  blobServiceProperties: () => blobServiceProperties,
  blobTagsString: () => blobTagsString,
  blobType: () => blobType,
  blobType1: () => blobType1,
  blobType2: () => blobType2,
  blockId: () => blockId,
  blocks: () => blocks,
  body: () => body,
  body1: () => body1,
  breakPeriod: () => breakPeriod,
  comp: () => comp,
  comp1: () => comp1,
  comp10: () => comp10,
  comp11: () => comp11,
  comp12: () => comp12,
  comp13: () => comp13,
  comp14: () => comp14,
  comp15: () => comp15,
  comp16: () => comp16,
  comp17: () => comp17,
  comp18: () => comp18,
  comp19: () => comp19,
  comp2: () => comp2,
  comp20: () => comp20,
  comp21: () => comp21,
  comp22: () => comp22,
  comp23: () => comp23,
  comp24: () => comp24,
  comp25: () => comp25,
  comp3: () => comp3,
  comp4: () => comp4,
  comp5: () => comp5,
  comp6: () => comp6,
  comp7: () => comp7,
  comp8: () => comp8,
  comp9: () => comp9,
  containerAcl: () => containerAcl,
  contentLength: () => contentLength,
  contentType: () => contentType,
  contentType1: () => contentType1,
  copyActionAbortConstant: () => copyActionAbortConstant,
  copyId: () => copyId,
  copySource: () => copySource,
  copySourceAuthorization: () => copySourceAuthorization,
  copySourceBlobProperties: () => copySourceBlobProperties,
  copySourceTags: () => copySourceTags,
  defaultEncryptionScope: () => defaultEncryptionScope,
  deleteSnapshots: () => deleteSnapshots,
  deletedContainerName: () => deletedContainerName,
  deletedContainerVersion: () => deletedContainerVersion,
  delimiter: () => delimiter,
  duration: () => duration,
  encryptionAlgorithm: () => encryptionAlgorithm,
  encryptionKey: () => encryptionKey,
  encryptionKeySha256: () => encryptionKeySha256,
  encryptionScope: () => encryptionScope,
  expiresOn: () => expiresOn,
  expiryOptions: () => expiryOptions,
  fileRequestIntent: () => fileRequestIntent,
  ifMatch: () => ifMatch,
  ifMatch1: () => ifMatch1,
  ifModifiedSince: () => ifModifiedSince,
  ifModifiedSince1: () => ifModifiedSince1,
  ifNoneMatch: () => ifNoneMatch,
  ifNoneMatch1: () => ifNoneMatch1,
  ifSequenceNumberEqualTo: () => ifSequenceNumberEqualTo,
  ifSequenceNumberLessThan: () => ifSequenceNumberLessThan,
  ifSequenceNumberLessThanOrEqualTo: () => ifSequenceNumberLessThanOrEqualTo,
  ifTags: () => ifTags,
  ifUnmodifiedSince: () => ifUnmodifiedSince,
  ifUnmodifiedSince1: () => ifUnmodifiedSince1,
  immutabilityPolicyExpiry: () => immutabilityPolicyExpiry,
  immutabilityPolicyMode: () => immutabilityPolicyMode,
  include: () => include,
  include1: () => include1,
  keyInfo: () => keyInfo,
  leaseId: () => leaseId,
  leaseId1: () => leaseId1,
  legalHold: () => legalHold,
  legalHold1: () => legalHold1,
  listType: () => listType,
  marker: () => marker,
  maxPageSize: () => maxPageSize,
  maxSize: () => maxSize,
  metadata: () => metadata,
  multipartContentType: () => multipartContentType,
  pageWrite: () => pageWrite,
  pageWrite1: () => pageWrite1,
  prefix: () => prefix,
  prevSnapshotUrl: () => prevSnapshotUrl,
  preventEncryptionScopeOverride: () => preventEncryptionScopeOverride,
  prevsnapshot: () => prevsnapshot,
  proposedLeaseId: () => proposedLeaseId,
  proposedLeaseId1: () => proposedLeaseId1,
  queryRequest: () => queryRequest,
  range: () => range,
  range1: () => range1,
  rangeGetContentCRC64: () => rangeGetContentCRC64,
  rangeGetContentMD5: () => rangeGetContentMD5,
  rehydratePriority: () => rehydratePriority,
  requestId: () => requestId,
  restype: () => restype,
  restype1: () => restype1,
  restype2: () => restype2,
  sealBlob: () => sealBlob,
  sequenceNumberAction: () => sequenceNumberAction,
  snapshot: () => snapshot,
  sourceContainerName: () => sourceContainerName,
  sourceContentCrc64: () => sourceContentCrc64,
  sourceContentMD5: () => sourceContentMD5,
  sourceEncryptionAlgorithm: () => sourceEncryptionAlgorithm,
  sourceEncryptionKey: () => sourceEncryptionKey,
  sourceEncryptionKeySha256: () => sourceEncryptionKeySha256,
  sourceIfMatch: () => sourceIfMatch,
  sourceIfModifiedSince: () => sourceIfModifiedSince,
  sourceIfNoneMatch: () => sourceIfNoneMatch,
  sourceIfTags: () => sourceIfTags,
  sourceIfUnmodifiedSince: () => sourceIfUnmodifiedSince,
  sourceLeaseId: () => sourceLeaseId,
  sourceRange: () => sourceRange,
  sourceRange1: () => sourceRange1,
  sourceUrl: () => sourceUrl,
  startFrom: () => startFrom,
  structuredBodyType: () => structuredBodyType,
  structuredContentLength: () => structuredContentLength,
  tags: () => tags,
  tier: () => tier,
  tier1: () => tier1,
  timeoutInSeconds: () => timeoutInSeconds,
  transactionalContentCrc64: () => transactionalContentCrc64,
  transactionalContentMD5: () => transactionalContentMD5,
  url: () => url,
  version: () => version,
  versionId: () => versionId,
  where: () => where,
  xMsRequiresSync: () => xMsRequiresSync
});
module.exports = __toCommonJS(parameters_exports);
var import_mappers = require("../models/mappers.js");
const contentType = {
  parameterPath: ["options", "contentType"],
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Content-Type",
    type: {
      name: "String"
    }
  }
};
const blobServiceProperties = {
  parameterPath: "blobServiceProperties",
  mapper: import_mappers.BlobServiceProperties
};
const accept = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const url = {
  parameterPath: "url",
  mapper: {
    serializedName: "url",
    required: true,
    xmlName: "url",
    type: {
      name: "String"
    }
  },
  skipEncoding: true
};
const restype = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "service",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const comp = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "properties",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const timeoutInSeconds = {
  parameterPath: ["options", "timeoutInSeconds"],
  mapper: {
    constraints: {
      InclusiveMinimum: 0
    },
    serializedName: "timeout",
    xmlName: "timeout",
    type: {
      name: "Number"
    }
  }
};
const version = {
  parameterPath: "version",
  mapper: {
    defaultValue: "2026-06-06",
    isConstant: true,
    serializedName: "x-ms-version",
    type: {
      name: "String"
    }
  }
};
const requestId = {
  parameterPath: ["options", "requestId"],
  mapper: {
    serializedName: "x-ms-client-request-id",
    xmlName: "x-ms-client-request-id",
    type: {
      name: "String"
    }
  }
};
const accept1 = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const comp1 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "stats",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const comp2 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "list",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const prefix = {
  parameterPath: ["options", "prefix"],
  mapper: {
    serializedName: "prefix",
    xmlName: "prefix",
    type: {
      name: "String"
    }
  }
};
const marker = {
  parameterPath: ["options", "marker"],
  mapper: {
    serializedName: "marker",
    xmlName: "marker",
    type: {
      name: "String"
    }
  }
};
const maxPageSize = {
  parameterPath: ["options", "maxPageSize"],
  mapper: {
    constraints: {
      InclusiveMinimum: 1
    },
    serializedName: "maxresults",
    xmlName: "maxresults",
    type: {
      name: "Number"
    }
  }
};
const include = {
  parameterPath: ["options", "include"],
  mapper: {
    serializedName: "include",
    xmlName: "include",
    xmlElementName: "ListContainersIncludeType",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Enum",
          allowedValues: ["metadata", "deleted", "system"]
        }
      }
    }
  },
  collectionFormat: "CSV"
};
const keyInfo = {
  parameterPath: "keyInfo",
  mapper: import_mappers.KeyInfo
};
const comp3 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "userdelegationkey",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const restype1 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "account",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const body = {
  parameterPath: "body",
  mapper: {
    serializedName: "body",
    required: true,
    xmlName: "body",
    type: {
      name: "Stream"
    }
  }
};
const comp4 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "batch",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const contentLength = {
  parameterPath: "contentLength",
  mapper: {
    serializedName: "Content-Length",
    required: true,
    xmlName: "Content-Length",
    type: {
      name: "Number"
    }
  }
};
const multipartContentType = {
  parameterPath: "multipartContentType",
  mapper: {
    serializedName: "Content-Type",
    required: true,
    xmlName: "Content-Type",
    type: {
      name: "String"
    }
  }
};
const comp5 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "blobs",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const where = {
  parameterPath: ["options", "where"],
  mapper: {
    serializedName: "where",
    xmlName: "where",
    type: {
      name: "String"
    }
  }
};
const restype2 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "container",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const metadata = {
  parameterPath: ["options", "metadata"],
  mapper: {
    serializedName: "x-ms-meta",
    xmlName: "x-ms-meta",
    headerCollectionPrefix: "x-ms-meta-",
    type: {
      name: "Dictionary",
      value: { type: { name: "String" } }
    }
  }
};
const access = {
  parameterPath: ["options", "access"],
  mapper: {
    serializedName: "x-ms-blob-public-access",
    xmlName: "x-ms-blob-public-access",
    type: {
      name: "Enum",
      allowedValues: ["container", "blob"]
    }
  }
};
const defaultEncryptionScope = {
  parameterPath: [
    "options",
    "containerEncryptionScope",
    "defaultEncryptionScope"
  ],
  mapper: {
    serializedName: "x-ms-default-encryption-scope",
    xmlName: "x-ms-default-encryption-scope",
    type: {
      name: "String"
    }
  }
};
const preventEncryptionScopeOverride = {
  parameterPath: [
    "options",
    "containerEncryptionScope",
    "preventEncryptionScopeOverride"
  ],
  mapper: {
    serializedName: "x-ms-deny-encryption-scope-override",
    xmlName: "x-ms-deny-encryption-scope-override",
    type: {
      name: "Boolean"
    }
  }
};
const leaseId = {
  parameterPath: ["options", "leaseAccessConditions", "leaseId"],
  mapper: {
    serializedName: "x-ms-lease-id",
    xmlName: "x-ms-lease-id",
    type: {
      name: "String"
    }
  }
};
const ifModifiedSince = {
  parameterPath: ["options", "modifiedAccessConditions", "ifModifiedSince"],
  mapper: {
    serializedName: "If-Modified-Since",
    xmlName: "If-Modified-Since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const ifUnmodifiedSince = {
  parameterPath: ["options", "modifiedAccessConditions", "ifUnmodifiedSince"],
  mapper: {
    serializedName: "If-Unmodified-Since",
    xmlName: "If-Unmodified-Since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const comp6 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "metadata",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const comp7 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "acl",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const containerAcl = {
  parameterPath: ["options", "containerAcl"],
  mapper: {
    serializedName: "containerAcl",
    xmlName: "SignedIdentifiers",
    xmlIsWrapped: true,
    xmlElementName: "SignedIdentifier",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Composite",
          className: "SignedIdentifier"
        }
      }
    }
  }
};
const comp8 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "undelete",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const deletedContainerName = {
  parameterPath: ["options", "deletedContainerName"],
  mapper: {
    serializedName: "x-ms-deleted-container-name",
    xmlName: "x-ms-deleted-container-name",
    type: {
      name: "String"
    }
  }
};
const deletedContainerVersion = {
  parameterPath: ["options", "deletedContainerVersion"],
  mapper: {
    serializedName: "x-ms-deleted-container-version",
    xmlName: "x-ms-deleted-container-version",
    type: {
      name: "String"
    }
  }
};
const comp9 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "rename",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const sourceContainerName = {
  parameterPath: "sourceContainerName",
  mapper: {
    serializedName: "x-ms-source-container-name",
    required: true,
    xmlName: "x-ms-source-container-name",
    type: {
      name: "String"
    }
  }
};
const sourceLeaseId = {
  parameterPath: ["options", "sourceLeaseId"],
  mapper: {
    serializedName: "x-ms-source-lease-id",
    xmlName: "x-ms-source-lease-id",
    type: {
      name: "String"
    }
  }
};
const comp10 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "lease",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const action = {
  parameterPath: "action",
  mapper: {
    defaultValue: "acquire",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const duration = {
  parameterPath: ["options", "duration"],
  mapper: {
    serializedName: "x-ms-lease-duration",
    xmlName: "x-ms-lease-duration",
    type: {
      name: "Number"
    }
  }
};
const proposedLeaseId = {
  parameterPath: ["options", "proposedLeaseId"],
  mapper: {
    serializedName: "x-ms-proposed-lease-id",
    xmlName: "x-ms-proposed-lease-id",
    type: {
      name: "String"
    }
  }
};
const action1 = {
  parameterPath: "action",
  mapper: {
    defaultValue: "release",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const leaseId1 = {
  parameterPath: "leaseId",
  mapper: {
    serializedName: "x-ms-lease-id",
    required: true,
    xmlName: "x-ms-lease-id",
    type: {
      name: "String"
    }
  }
};
const action2 = {
  parameterPath: "action",
  mapper: {
    defaultValue: "renew",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const action3 = {
  parameterPath: "action",
  mapper: {
    defaultValue: "break",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const breakPeriod = {
  parameterPath: ["options", "breakPeriod"],
  mapper: {
    serializedName: "x-ms-lease-break-period",
    xmlName: "x-ms-lease-break-period",
    type: {
      name: "Number"
    }
  }
};
const action4 = {
  parameterPath: "action",
  mapper: {
    defaultValue: "change",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const proposedLeaseId1 = {
  parameterPath: "proposedLeaseId",
  mapper: {
    serializedName: "x-ms-proposed-lease-id",
    required: true,
    xmlName: "x-ms-proposed-lease-id",
    type: {
      name: "String"
    }
  }
};
const include1 = {
  parameterPath: ["options", "include"],
  mapper: {
    serializedName: "include",
    xmlName: "include",
    xmlElementName: "ListBlobsIncludeItem",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Enum",
          allowedValues: [
            "copy",
            "deleted",
            "metadata",
            "snapshots",
            "uncommittedblobs",
            "versions",
            "tags",
            "immutabilitypolicy",
            "legalhold",
            "deletedwithversions"
          ]
        }
      }
    }
  },
  collectionFormat: "CSV"
};
const startFrom = {
  parameterPath: ["options", "startFrom"],
  mapper: {
    serializedName: "startFrom",
    xmlName: "startFrom",
    type: {
      name: "String"
    }
  }
};
const delimiter = {
  parameterPath: "delimiter",
  mapper: {
    serializedName: "delimiter",
    required: true,
    xmlName: "delimiter",
    type: {
      name: "String"
    }
  }
};
const snapshot = {
  parameterPath: ["options", "snapshot"],
  mapper: {
    serializedName: "snapshot",
    xmlName: "snapshot",
    type: {
      name: "String"
    }
  }
};
const versionId = {
  parameterPath: ["options", "versionId"],
  mapper: {
    serializedName: "versionid",
    xmlName: "versionid",
    type: {
      name: "String"
    }
  }
};
const range = {
  parameterPath: ["options", "range"],
  mapper: {
    serializedName: "x-ms-range",
    xmlName: "x-ms-range",
    type: {
      name: "String"
    }
  }
};
const rangeGetContentMD5 = {
  parameterPath: ["options", "rangeGetContentMD5"],
  mapper: {
    serializedName: "x-ms-range-get-content-md5",
    xmlName: "x-ms-range-get-content-md5",
    type: {
      name: "Boolean"
    }
  }
};
const rangeGetContentCRC64 = {
  parameterPath: ["options", "rangeGetContentCRC64"],
  mapper: {
    serializedName: "x-ms-range-get-content-crc64",
    xmlName: "x-ms-range-get-content-crc64",
    type: {
      name: "Boolean"
    }
  }
};
const structuredBodyType = {
  parameterPath: ["options", "structuredBodyType"],
  mapper: {
    serializedName: "x-ms-structured-body",
    xmlName: "x-ms-structured-body",
    type: {
      name: "String"
    }
  }
};
const encryptionKey = {
  parameterPath: ["options", "cpkInfo", "encryptionKey"],
  mapper: {
    serializedName: "x-ms-encryption-key",
    xmlName: "x-ms-encryption-key",
    type: {
      name: "String"
    }
  }
};
const encryptionKeySha256 = {
  parameterPath: ["options", "cpkInfo", "encryptionKeySha256"],
  mapper: {
    serializedName: "x-ms-encryption-key-sha256",
    xmlName: "x-ms-encryption-key-sha256",
    type: {
      name: "String"
    }
  }
};
const encryptionAlgorithm = {
  parameterPath: ["options", "cpkInfo", "encryptionAlgorithm"],
  mapper: {
    serializedName: "x-ms-encryption-algorithm",
    xmlName: "x-ms-encryption-algorithm",
    type: {
      name: "String"
    }
  }
};
const ifMatch = {
  parameterPath: ["options", "modifiedAccessConditions", "ifMatch"],
  mapper: {
    serializedName: "If-Match",
    xmlName: "If-Match",
    type: {
      name: "String"
    }
  }
};
const ifNoneMatch = {
  parameterPath: ["options", "modifiedAccessConditions", "ifNoneMatch"],
  mapper: {
    serializedName: "If-None-Match",
    xmlName: "If-None-Match",
    type: {
      name: "String"
    }
  }
};
const ifTags = {
  parameterPath: ["options", "modifiedAccessConditions", "ifTags"],
  mapper: {
    serializedName: "x-ms-if-tags",
    xmlName: "x-ms-if-tags",
    type: {
      name: "String"
    }
  }
};
const deleteSnapshots = {
  parameterPath: ["options", "deleteSnapshots"],
  mapper: {
    serializedName: "x-ms-delete-snapshots",
    xmlName: "x-ms-delete-snapshots",
    type: {
      name: "Enum",
      allowedValues: ["include", "only"]
    }
  }
};
const blobDeleteType = {
  parameterPath: ["options", "blobDeleteType"],
  mapper: {
    serializedName: "deletetype",
    xmlName: "deletetype",
    type: {
      name: "String"
    }
  }
};
const accessTierIfModifiedSince = {
  parameterPath: ["options", "accessTierIfModifiedSince"],
  mapper: {
    serializedName: "x-ms-access-tier-if-modified-since",
    xmlName: "x-ms-access-tier-if-modified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const accessTierIfUnmodifiedSince = {
  parameterPath: ["options", "accessTierIfUnmodifiedSince"],
  mapper: {
    serializedName: "x-ms-access-tier-if-unmodified-since",
    xmlName: "x-ms-access-tier-if-unmodified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const comp11 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "expiry",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const expiryOptions = {
  parameterPath: "expiryOptions",
  mapper: {
    serializedName: "x-ms-expiry-option",
    required: true,
    xmlName: "x-ms-expiry-option",
    type: {
      name: "String"
    }
  }
};
const expiresOn = {
  parameterPath: ["options", "expiresOn"],
  mapper: {
    serializedName: "x-ms-expiry-time",
    xmlName: "x-ms-expiry-time",
    type: {
      name: "String"
    }
  }
};
const blobCacheControl = {
  parameterPath: ["options", "blobHttpHeaders", "blobCacheControl"],
  mapper: {
    serializedName: "x-ms-blob-cache-control",
    xmlName: "x-ms-blob-cache-control",
    type: {
      name: "String"
    }
  }
};
const blobContentType = {
  parameterPath: ["options", "blobHttpHeaders", "blobContentType"],
  mapper: {
    serializedName: "x-ms-blob-content-type",
    xmlName: "x-ms-blob-content-type",
    type: {
      name: "String"
    }
  }
};
const blobContentMD5 = {
  parameterPath: ["options", "blobHttpHeaders", "blobContentMD5"],
  mapper: {
    serializedName: "x-ms-blob-content-md5",
    xmlName: "x-ms-blob-content-md5",
    type: {
      name: "ByteArray"
    }
  }
};
const blobContentEncoding = {
  parameterPath: ["options", "blobHttpHeaders", "blobContentEncoding"],
  mapper: {
    serializedName: "x-ms-blob-content-encoding",
    xmlName: "x-ms-blob-content-encoding",
    type: {
      name: "String"
    }
  }
};
const blobContentLanguage = {
  parameterPath: ["options", "blobHttpHeaders", "blobContentLanguage"],
  mapper: {
    serializedName: "x-ms-blob-content-language",
    xmlName: "x-ms-blob-content-language",
    type: {
      name: "String"
    }
  }
};
const blobContentDisposition = {
  parameterPath: ["options", "blobHttpHeaders", "blobContentDisposition"],
  mapper: {
    serializedName: "x-ms-blob-content-disposition",
    xmlName: "x-ms-blob-content-disposition",
    type: {
      name: "String"
    }
  }
};
const comp12 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "immutabilityPolicies",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const immutabilityPolicyExpiry = {
  parameterPath: ["options", "immutabilityPolicyExpiry"],
  mapper: {
    serializedName: "x-ms-immutability-policy-until-date",
    xmlName: "x-ms-immutability-policy-until-date",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const immutabilityPolicyMode = {
  parameterPath: ["options", "immutabilityPolicyMode"],
  mapper: {
    serializedName: "x-ms-immutability-policy-mode",
    xmlName: "x-ms-immutability-policy-mode",
    type: {
      name: "Enum",
      allowedValues: ["Mutable", "Unlocked", "Locked"]
    }
  }
};
const comp13 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "legalhold",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const legalHold = {
  parameterPath: "legalHold",
  mapper: {
    serializedName: "x-ms-legal-hold",
    required: true,
    xmlName: "x-ms-legal-hold",
    type: {
      name: "Boolean"
    }
  }
};
const encryptionScope = {
  parameterPath: ["options", "encryptionScope"],
  mapper: {
    serializedName: "x-ms-encryption-scope",
    xmlName: "x-ms-encryption-scope",
    type: {
      name: "String"
    }
  }
};
const comp14 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "snapshot",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const tier = {
  parameterPath: ["options", "tier"],
  mapper: {
    serializedName: "x-ms-access-tier",
    xmlName: "x-ms-access-tier",
    type: {
      name: "Enum",
      allowedValues: [
        "P4",
        "P6",
        "P10",
        "P15",
        "P20",
        "P30",
        "P40",
        "P50",
        "P60",
        "P70",
        "P80",
        "Hot",
        "Cool",
        "Archive",
        "Cold",
        "Smart"
      ]
    }
  }
};
const rehydratePriority = {
  parameterPath: ["options", "rehydratePriority"],
  mapper: {
    serializedName: "x-ms-rehydrate-priority",
    xmlName: "x-ms-rehydrate-priority",
    type: {
      name: "Enum",
      allowedValues: ["High", "Standard"]
    }
  }
};
const sourceIfModifiedSince = {
  parameterPath: [
    "options",
    "sourceModifiedAccessConditions",
    "sourceIfModifiedSince"
  ],
  mapper: {
    serializedName: "x-ms-source-if-modified-since",
    xmlName: "x-ms-source-if-modified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const sourceIfUnmodifiedSince = {
  parameterPath: [
    "options",
    "sourceModifiedAccessConditions",
    "sourceIfUnmodifiedSince"
  ],
  mapper: {
    serializedName: "x-ms-source-if-unmodified-since",
    xmlName: "x-ms-source-if-unmodified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const sourceIfMatch = {
  parameterPath: ["options", "sourceModifiedAccessConditions", "sourceIfMatch"],
  mapper: {
    serializedName: "x-ms-source-if-match",
    xmlName: "x-ms-source-if-match",
    type: {
      name: "String"
    }
  }
};
const sourceIfNoneMatch = {
  parameterPath: [
    "options",
    "sourceModifiedAccessConditions",
    "sourceIfNoneMatch"
  ],
  mapper: {
    serializedName: "x-ms-source-if-none-match",
    xmlName: "x-ms-source-if-none-match",
    type: {
      name: "String"
    }
  }
};
const sourceIfTags = {
  parameterPath: ["options", "sourceModifiedAccessConditions", "sourceIfTags"],
  mapper: {
    serializedName: "x-ms-source-if-tags",
    xmlName: "x-ms-source-if-tags",
    type: {
      name: "String"
    }
  }
};
const copySource = {
  parameterPath: "copySource",
  mapper: {
    serializedName: "x-ms-copy-source",
    required: true,
    xmlName: "x-ms-copy-source",
    type: {
      name: "String"
    }
  }
};
const blobTagsString = {
  parameterPath: ["options", "blobTagsString"],
  mapper: {
    serializedName: "x-ms-tags",
    xmlName: "x-ms-tags",
    type: {
      name: "String"
    }
  }
};
const sealBlob = {
  parameterPath: ["options", "sealBlob"],
  mapper: {
    serializedName: "x-ms-seal-blob",
    xmlName: "x-ms-seal-blob",
    type: {
      name: "Boolean"
    }
  }
};
const legalHold1 = {
  parameterPath: ["options", "legalHold"],
  mapper: {
    serializedName: "x-ms-legal-hold",
    xmlName: "x-ms-legal-hold",
    type: {
      name: "Boolean"
    }
  }
};
const xMsRequiresSync = {
  parameterPath: "xMsRequiresSync",
  mapper: {
    defaultValue: "true",
    isConstant: true,
    serializedName: "x-ms-requires-sync",
    type: {
      name: "String"
    }
  }
};
const sourceContentMD5 = {
  parameterPath: ["options", "sourceContentMD5"],
  mapper: {
    serializedName: "x-ms-source-content-md5",
    xmlName: "x-ms-source-content-md5",
    type: {
      name: "ByteArray"
    }
  }
};
const copySourceAuthorization = {
  parameterPath: ["options", "copySourceAuthorization"],
  mapper: {
    serializedName: "x-ms-copy-source-authorization",
    xmlName: "x-ms-copy-source-authorization",
    type: {
      name: "String"
    }
  }
};
const copySourceTags = {
  parameterPath: ["options", "copySourceTags"],
  mapper: {
    serializedName: "x-ms-copy-source-tag-option",
    xmlName: "x-ms-copy-source-tag-option",
    type: {
      name: "Enum",
      allowedValues: ["REPLACE", "COPY"]
    }
  }
};
const fileRequestIntent = {
  parameterPath: ["options", "fileRequestIntent"],
  mapper: {
    serializedName: "x-ms-file-request-intent",
    xmlName: "x-ms-file-request-intent",
    type: {
      name: "String"
    }
  }
};
const comp15 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "copy",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const copyActionAbortConstant = {
  parameterPath: "copyActionAbortConstant",
  mapper: {
    defaultValue: "abort",
    isConstant: true,
    serializedName: "x-ms-copy-action",
    type: {
      name: "String"
    }
  }
};
const copyId = {
  parameterPath: "copyId",
  mapper: {
    serializedName: "copyid",
    required: true,
    xmlName: "copyid",
    type: {
      name: "String"
    }
  }
};
const comp16 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "tier",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const tier1 = {
  parameterPath: "tier",
  mapper: {
    serializedName: "x-ms-access-tier",
    required: true,
    xmlName: "x-ms-access-tier",
    type: {
      name: "Enum",
      allowedValues: [
        "P4",
        "P6",
        "P10",
        "P15",
        "P20",
        "P30",
        "P40",
        "P50",
        "P60",
        "P70",
        "P80",
        "Hot",
        "Cool",
        "Archive",
        "Cold",
        "Smart"
      ]
    }
  }
};
const queryRequest = {
  parameterPath: ["options", "queryRequest"],
  mapper: import_mappers.QueryRequest
};
const comp17 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "query",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const comp18 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "tags",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const ifModifiedSince1 = {
  parameterPath: ["options", "blobModifiedAccessConditions", "ifModifiedSince"],
  mapper: {
    serializedName: "x-ms-blob-if-modified-since",
    xmlName: "x-ms-blob-if-modified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const ifUnmodifiedSince1 = {
  parameterPath: [
    "options",
    "blobModifiedAccessConditions",
    "ifUnmodifiedSince"
  ],
  mapper: {
    serializedName: "x-ms-blob-if-unmodified-since",
    xmlName: "x-ms-blob-if-unmodified-since",
    type: {
      name: "DateTimeRfc1123"
    }
  }
};
const ifMatch1 = {
  parameterPath: ["options", "blobModifiedAccessConditions", "ifMatch"],
  mapper: {
    serializedName: "x-ms-blob-if-match",
    xmlName: "x-ms-blob-if-match",
    type: {
      name: "String"
    }
  }
};
const ifNoneMatch1 = {
  parameterPath: ["options", "blobModifiedAccessConditions", "ifNoneMatch"],
  mapper: {
    serializedName: "x-ms-blob-if-none-match",
    xmlName: "x-ms-blob-if-none-match",
    type: {
      name: "String"
    }
  }
};
const tags = {
  parameterPath: ["options", "tags"],
  mapper: import_mappers.BlobTags
};
const transactionalContentMD5 = {
  parameterPath: ["options", "transactionalContentMD5"],
  mapper: {
    serializedName: "Content-MD5",
    xmlName: "Content-MD5",
    type: {
      name: "ByteArray"
    }
  }
};
const transactionalContentCrc64 = {
  parameterPath: ["options", "transactionalContentCrc64"],
  mapper: {
    serializedName: "x-ms-content-crc64",
    xmlName: "x-ms-content-crc64",
    type: {
      name: "ByteArray"
    }
  }
};
const blobType = {
  parameterPath: "blobType",
  mapper: {
    defaultValue: "PageBlob",
    isConstant: true,
    serializedName: "x-ms-blob-type",
    type: {
      name: "String"
    }
  }
};
const blobContentLength = {
  parameterPath: "blobContentLength",
  mapper: {
    serializedName: "x-ms-blob-content-length",
    required: true,
    xmlName: "x-ms-blob-content-length",
    type: {
      name: "Number"
    }
  }
};
const blobSequenceNumber = {
  parameterPath: ["options", "blobSequenceNumber"],
  mapper: {
    defaultValue: 0,
    serializedName: "x-ms-blob-sequence-number",
    xmlName: "x-ms-blob-sequence-number",
    type: {
      name: "Number"
    }
  }
};
const contentType1 = {
  parameterPath: ["options", "contentType"],
  mapper: {
    defaultValue: "application/octet-stream",
    isConstant: true,
    serializedName: "Content-Type",
    type: {
      name: "String"
    }
  }
};
const body1 = {
  parameterPath: "body",
  mapper: {
    serializedName: "body",
    required: true,
    xmlName: "body",
    type: {
      name: "Stream"
    }
  }
};
const accept2 = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const comp19 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "page",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const pageWrite = {
  parameterPath: "pageWrite",
  mapper: {
    defaultValue: "update",
    isConstant: true,
    serializedName: "x-ms-page-write",
    type: {
      name: "String"
    }
  }
};
const ifSequenceNumberLessThanOrEqualTo = {
  parameterPath: [
    "options",
    "sequenceNumberAccessConditions",
    "ifSequenceNumberLessThanOrEqualTo"
  ],
  mapper: {
    serializedName: "x-ms-if-sequence-number-le",
    xmlName: "x-ms-if-sequence-number-le",
    type: {
      name: "Number"
    }
  }
};
const ifSequenceNumberLessThan = {
  parameterPath: [
    "options",
    "sequenceNumberAccessConditions",
    "ifSequenceNumberLessThan"
  ],
  mapper: {
    serializedName: "x-ms-if-sequence-number-lt",
    xmlName: "x-ms-if-sequence-number-lt",
    type: {
      name: "Number"
    }
  }
};
const ifSequenceNumberEqualTo = {
  parameterPath: [
    "options",
    "sequenceNumberAccessConditions",
    "ifSequenceNumberEqualTo"
  ],
  mapper: {
    serializedName: "x-ms-if-sequence-number-eq",
    xmlName: "x-ms-if-sequence-number-eq",
    type: {
      name: "Number"
    }
  }
};
const structuredContentLength = {
  parameterPath: ["options", "structuredContentLength"],
  mapper: {
    serializedName: "x-ms-structured-content-length",
    xmlName: "x-ms-structured-content-length",
    type: {
      name: "Number"
    }
  }
};
const pageWrite1 = {
  parameterPath: "pageWrite",
  mapper: {
    defaultValue: "clear",
    isConstant: true,
    serializedName: "x-ms-page-write",
    type: {
      name: "String"
    }
  }
};
const sourceUrl = {
  parameterPath: "sourceUrl",
  mapper: {
    serializedName: "x-ms-copy-source",
    required: true,
    xmlName: "x-ms-copy-source",
    type: {
      name: "String"
    }
  }
};
const sourceRange = {
  parameterPath: "sourceRange",
  mapper: {
    serializedName: "x-ms-source-range",
    required: true,
    xmlName: "x-ms-source-range",
    type: {
      name: "String"
    }
  }
};
const sourceContentCrc64 = {
  parameterPath: ["options", "sourceContentCrc64"],
  mapper: {
    serializedName: "x-ms-source-content-crc64",
    xmlName: "x-ms-source-content-crc64",
    type: {
      name: "ByteArray"
    }
  }
};
const range1 = {
  parameterPath: "range",
  mapper: {
    serializedName: "x-ms-range",
    required: true,
    xmlName: "x-ms-range",
    type: {
      name: "String"
    }
  }
};
const sourceEncryptionKey = {
  parameterPath: ["options", "sourceCpkInfo", "sourceEncryptionKey"],
  mapper: {
    serializedName: "x-ms-source-encryption-key",
    xmlName: "x-ms-source-encryption-key",
    type: {
      name: "String"
    }
  }
};
const sourceEncryptionKeySha256 = {
  parameterPath: ["options", "sourceCpkInfo", "sourceEncryptionKeySha256"],
  mapper: {
    serializedName: "x-ms-source-encryption-key-sha256",
    xmlName: "x-ms-source-encryption-key-sha256",
    type: {
      name: "String"
    }
  }
};
const sourceEncryptionAlgorithm = {
  parameterPath: ["options", "sourceCpkInfo", "sourceEncryptionAlgorithm"],
  mapper: {
    serializedName: "x-ms-source-encryption-algorithm",
    xmlName: "x-ms-source-encryption-algorithm",
    type: {
      name: "String"
    }
  }
};
const comp20 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "pagelist",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const prevsnapshot = {
  parameterPath: ["options", "prevsnapshot"],
  mapper: {
    serializedName: "prevsnapshot",
    xmlName: "prevsnapshot",
    type: {
      name: "String"
    }
  }
};
const prevSnapshotUrl = {
  parameterPath: ["options", "prevSnapshotUrl"],
  mapper: {
    serializedName: "x-ms-previous-snapshot-url",
    xmlName: "x-ms-previous-snapshot-url",
    type: {
      name: "String"
    }
  }
};
const sequenceNumberAction = {
  parameterPath: "sequenceNumberAction",
  mapper: {
    serializedName: "x-ms-sequence-number-action",
    required: true,
    xmlName: "x-ms-sequence-number-action",
    type: {
      name: "Enum",
      allowedValues: ["max", "update", "increment"]
    }
  }
};
const comp21 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "incrementalcopy",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const blobType1 = {
  parameterPath: "blobType",
  mapper: {
    defaultValue: "AppendBlob",
    isConstant: true,
    serializedName: "x-ms-blob-type",
    type: {
      name: "String"
    }
  }
};
const comp22 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "appendblock",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const maxSize = {
  parameterPath: ["options", "appendPositionAccessConditions", "maxSize"],
  mapper: {
    serializedName: "x-ms-blob-condition-maxsize",
    xmlName: "x-ms-blob-condition-maxsize",
    type: {
      name: "Number"
    }
  }
};
const appendPosition = {
  parameterPath: [
    "options",
    "appendPositionAccessConditions",
    "appendPosition"
  ],
  mapper: {
    serializedName: "x-ms-blob-condition-appendpos",
    xmlName: "x-ms-blob-condition-appendpos",
    type: {
      name: "Number"
    }
  }
};
const sourceRange1 = {
  parameterPath: ["options", "sourceRange"],
  mapper: {
    serializedName: "x-ms-source-range",
    xmlName: "x-ms-source-range",
    type: {
      name: "String"
    }
  }
};
const comp23 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "seal",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const blobType2 = {
  parameterPath: "blobType",
  mapper: {
    defaultValue: "BlockBlob",
    isConstant: true,
    serializedName: "x-ms-blob-type",
    type: {
      name: "String"
    }
  }
};
const copySourceBlobProperties = {
  parameterPath: ["options", "copySourceBlobProperties"],
  mapper: {
    serializedName: "x-ms-copy-source-blob-properties",
    xmlName: "x-ms-copy-source-blob-properties",
    type: {
      name: "Boolean"
    }
  }
};
const comp24 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "block",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const blockId = {
  parameterPath: "blockId",
  mapper: {
    serializedName: "blockid",
    required: true,
    xmlName: "blockid",
    type: {
      name: "String"
    }
  }
};
const blocks = {
  parameterPath: "blocks",
  mapper: import_mappers.BlockLookupList
};
const comp25 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "blocklist",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const listType = {
  parameterPath: "listType",
  mapper: {
    defaultValue: "committed",
    serializedName: "blocklisttype",
    required: true,
    xmlName: "blocklisttype",
    type: {
      name: "Enum",
      allowedValues: ["committed", "uncommitted", "all"]
    }
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  accept,
  accept1,
  accept2,
  access,
  accessTierIfModifiedSince,
  accessTierIfUnmodifiedSince,
  action,
  action1,
  action2,
  action3,
  action4,
  appendPosition,
  blobCacheControl,
  blobContentDisposition,
  blobContentEncoding,
  blobContentLanguage,
  blobContentLength,
  blobContentMD5,
  blobContentType,
  blobDeleteType,
  blobSequenceNumber,
  blobServiceProperties,
  blobTagsString,
  blobType,
  blobType1,
  blobType2,
  blockId,
  blocks,
  body,
  body1,
  breakPeriod,
  comp,
  comp1,
  comp10,
  comp11,
  comp12,
  comp13,
  comp14,
  comp15,
  comp16,
  comp17,
  comp18,
  comp19,
  comp2,
  comp20,
  comp21,
  comp22,
  comp23,
  comp24,
  comp25,
  comp3,
  comp4,
  comp5,
  comp6,
  comp7,
  comp8,
  comp9,
  containerAcl,
  contentLength,
  contentType,
  contentType1,
  copyActionAbortConstant,
  copyId,
  copySource,
  copySourceAuthorization,
  copySourceBlobProperties,
  copySourceTags,
  defaultEncryptionScope,
  deleteSnapshots,
  deletedContainerName,
  deletedContainerVersion,
  delimiter,
  duration,
  encryptionAlgorithm,
  encryptionKey,
  encryptionKeySha256,
  encryptionScope,
  expiresOn,
  expiryOptions,
  fileRequestIntent,
  ifMatch,
  ifMatch1,
  ifModifiedSince,
  ifModifiedSince1,
  ifNoneMatch,
  ifNoneMatch1,
  ifSequenceNumberEqualTo,
  ifSequenceNumberLessThan,
  ifSequenceNumberLessThanOrEqualTo,
  ifTags,
  ifUnmodifiedSince,
  ifUnmodifiedSince1,
  immutabilityPolicyExpiry,
  immutabilityPolicyMode,
  include,
  include1,
  keyInfo,
  leaseId,
  leaseId1,
  legalHold,
  legalHold1,
  listType,
  marker,
  maxPageSize,
  maxSize,
  metadata,
  multipartContentType,
  pageWrite,
  pageWrite1,
  prefix,
  prevSnapshotUrl,
  preventEncryptionScopeOverride,
  prevsnapshot,
  proposedLeaseId,
  proposedLeaseId1,
  queryRequest,
  range,
  range1,
  rangeGetContentCRC64,
  rangeGetContentMD5,
  rehydratePriority,
  requestId,
  restype,
  restype1,
  restype2,
  sealBlob,
  sequenceNumberAction,
  snapshot,
  sourceContainerName,
  sourceContentCrc64,
  sourceContentMD5,
  sourceEncryptionAlgorithm,
  sourceEncryptionKey,
  sourceEncryptionKeySha256,
  sourceIfMatch,
  sourceIfModifiedSince,
  sourceIfNoneMatch,
  sourceIfTags,
  sourceIfUnmodifiedSince,
  sourceLeaseId,
  sourceRange,
  sourceRange1,
  sourceUrl,
  startFrom,
  structuredBodyType,
  structuredContentLength,
  tags,
  tier,
  tier1,
  timeoutInSeconds,
  transactionalContentCrc64,
  transactionalContentMD5,
  url,
  version,
  versionId,
  where,
  xMsRequiresSync
});
//# sourceMappingURL=parameters.js.map
