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,
  accept3: () => accept3,
  accessTier: () => accessTier,
  action: () => action,
  action1: () => action1,
  action2: () => action2,
  action3: () => action3,
  action4: () => action4,
  allowSourceTrailingDot: () => allowSourceTrailingDot,
  allowTrailingDot: () => allowTrailingDot,
  body: () => body,
  breakPeriod: () => breakPeriod,
  comp: () => comp,
  comp1: () => comp1,
  comp10: () => comp10,
  comp11: () => comp11,
  comp12: () => comp12,
  comp13: () => comp13,
  comp14: () => comp14,
  comp15: () => comp15,
  comp2: () => comp2,
  comp3: () => comp3,
  comp4: () => comp4,
  comp5: () => comp5,
  comp6: () => comp6,
  comp7: () => comp7,
  comp8: () => comp8,
  comp9: () => comp9,
  contentLength: () => contentLength,
  contentLength1: () => contentLength1,
  contentMD5: () => contentMD5,
  contentType: () => contentType,
  contentType1: () => contentType1,
  contentType2: () => contentType2,
  copyActionAbortConstant: () => copyActionAbortConstant,
  copyId: () => copyId,
  copySource: () => copySource,
  copySourceAuthorization: () => copySourceAuthorization,
  deleteSnapshots: () => deleteSnapshots,
  deletedShareName: () => deletedShareName,
  deletedShareVersion: () => deletedShareVersion,
  destinationLeaseId: () => destinationLeaseId,
  duration: () => duration,
  enableSnapshotVirtualDirectoryAccess: () => enableSnapshotVirtualDirectoryAccess,
  enabledProtocols: () => enabledProtocols,
  fileAttributes: () => fileAttributes,
  fileAttributes1: () => fileAttributes1,
  fileCacheControl: () => fileCacheControl,
  fileChangeOn: () => fileChangeOn,
  fileChangeTime: () => fileChangeTime,
  fileContentDisposition: () => fileContentDisposition,
  fileContentEncoding: () => fileContentEncoding,
  fileContentLanguage: () => fileContentLanguage,
  fileContentLength: () => fileContentLength,
  fileContentLength1: () => fileContentLength1,
  fileContentMD5: () => fileContentMD5,
  fileContentType: () => fileContentType,
  fileCreatedOn: () => fileCreatedOn,
  fileCreationTime: () => fileCreationTime,
  fileLastWriteOn: () => fileLastWriteOn,
  fileLastWriteTime: () => fileLastWriteTime,
  fileLastWrittenMode: () => fileLastWrittenMode,
  fileMode: () => fileMode,
  fileModeCopyMode: () => fileModeCopyMode,
  fileOwnerCopyMode: () => fileOwnerCopyMode,
  filePermission: () => filePermission,
  filePermissionCopyMode: () => filePermissionCopyMode,
  filePermissionFormat: () => filePermissionFormat,
  filePermissionKey: () => filePermissionKey,
  filePermissionKey1: () => filePermissionKey1,
  filePropertySemantics: () => filePropertySemantics,
  fileRangeWrite: () => fileRangeWrite,
  fileRangeWriteFromUrl: () => fileRangeWriteFromUrl,
  fileRequestIntent: () => fileRequestIntent,
  fileTypeConstant: () => fileTypeConstant,
  group: () => group,
  handleId: () => handleId,
  ignoreReadOnly: () => ignoreReadOnly,
  ignoreReadOnly1: () => ignoreReadOnly1,
  include: () => include,
  include1: () => include1,
  includeExtendedInfo: () => includeExtendedInfo,
  keyInfo: () => keyInfo,
  leaseId: () => leaseId,
  leaseId1: () => leaseId1,
  linkText: () => linkText,
  marker: () => marker,
  maxResults: () => maxResults,
  metadata: () => metadata,
  nfsFileType: () => nfsFileType,
  owner: () => owner,
  paidBurstingEnabled: () => paidBurstingEnabled,
  paidBurstingMaxBandwidthMibps: () => paidBurstingMaxBandwidthMibps,
  paidBurstingMaxIops: () => paidBurstingMaxIops,
  prefix: () => prefix,
  prevsharesnapshot: () => prevsharesnapshot,
  properties: () => properties,
  proposedLeaseId: () => proposedLeaseId,
  quota: () => quota,
  range: () => range,
  range1: () => range1,
  rangeGetContentMD5: () => rangeGetContentMD5,
  recursive: () => recursive,
  renameSource: () => renameSource,
  replaceIfExists: () => replaceIfExists,
  requestId: () => requestId,
  restype: () => restype,
  restype1: () => restype1,
  restype2: () => restype2,
  restype3: () => restype3,
  restype4: () => restype4,
  rootSquash: () => rootSquash,
  setArchiveAttribute: () => setArchiveAttribute,
  shareAcl: () => shareAcl,
  sharePermission: () => sharePermission,
  shareProvisionedBandwidthMibps: () => shareProvisionedBandwidthMibps,
  shareProvisionedIops: () => shareProvisionedIops,
  shareSnapshot: () => shareSnapshot,
  sourceContentCrc64: () => sourceContentCrc64,
  sourceIfMatchCrc64: () => sourceIfMatchCrc64,
  sourceIfNoneMatchCrc64: () => sourceIfNoneMatchCrc64,
  sourceLeaseId: () => sourceLeaseId,
  sourceRange: () => sourceRange,
  structuredBodyType: () => structuredBodyType,
  structuredContentLength: () => structuredContentLength,
  supportRename: () => supportRename,
  targetFile: () => targetFile,
  timeoutInSeconds: () => timeoutInSeconds,
  url: () => url,
  version: () => version
});
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 properties = {
  parameterPath: "properties",
  mapper: import_mappers.FileServiceProperties
};
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 fileRequestIntent = {
  parameterPath: ["options", "fileRequestIntent"],
  mapper: {
    serializedName: "x-ms-file-request-intent",
    xmlName: "x-ms-file-request-intent",
    type: {
      name: "String"
    }
  }
};
const accept1 = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const comp1 = {
  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 maxResults = {
  parameterPath: ["options", "maxResults"],
  mapper: {
    constraints: {
      InclusiveMinimum: 1
    },
    serializedName: "maxresults",
    xmlName: "maxresults",
    type: {
      name: "Number"
    }
  }
};
const include = {
  parameterPath: ["options", "include"],
  mapper: {
    serializedName: "include",
    xmlName: "include",
    xmlElementName: "ListSharesIncludeType",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Enum",
          allowedValues: ["snapshots", "metadata", "deleted"]
        }
      }
    }
  },
  collectionFormat: "CSV"
};
const keyInfo = {
  parameterPath: "keyInfo",
  mapper: import_mappers.KeyInfo
};
const comp2 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "userdelegationkey",
    isConstant: true,
    serializedName: "comp",
    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 restype1 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "share",
    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 quota = {
  parameterPath: ["options", "quota"],
  mapper: {
    constraints: {
      InclusiveMinimum: 1
    },
    serializedName: "x-ms-share-quota",
    xmlName: "x-ms-share-quota",
    type: {
      name: "Number"
    }
  }
};
const accessTier = {
  parameterPath: ["options", "accessTier"],
  mapper: {
    serializedName: "x-ms-access-tier",
    xmlName: "x-ms-access-tier",
    type: {
      name: "Enum",
      allowedValues: ["TransactionOptimized", "Hot", "Cool", "Premium"]
    }
  }
};
const enabledProtocols = {
  parameterPath: ["options", "enabledProtocols"],
  mapper: {
    serializedName: "x-ms-enabled-protocols",
    xmlName: "x-ms-enabled-protocols",
    type: {
      name: "String"
    }
  }
};
const rootSquash = {
  parameterPath: ["options", "rootSquash"],
  mapper: {
    serializedName: "x-ms-root-squash",
    xmlName: "x-ms-root-squash",
    type: {
      name: "Enum",
      allowedValues: ["NoRootSquash", "RootSquash", "AllSquash"]
    }
  }
};
const enableSnapshotVirtualDirectoryAccess = {
  parameterPath: ["options", "enableSnapshotVirtualDirectoryAccess"],
  mapper: {
    serializedName: "x-ms-enable-snapshot-virtual-directory-access",
    xmlName: "x-ms-enable-snapshot-virtual-directory-access",
    type: {
      name: "Boolean"
    }
  }
};
const paidBurstingEnabled = {
  parameterPath: ["options", "paidBurstingEnabled"],
  mapper: {
    serializedName: "x-ms-share-paid-bursting-enabled",
    xmlName: "x-ms-share-paid-bursting-enabled",
    type: {
      name: "Boolean"
    }
  }
};
const paidBurstingMaxBandwidthMibps = {
  parameterPath: ["options", "paidBurstingMaxBandwidthMibps"],
  mapper: {
    serializedName: "x-ms-share-paid-bursting-max-bandwidth-mibps",
    xmlName: "x-ms-share-paid-bursting-max-bandwidth-mibps",
    type: {
      name: "Number"
    }
  }
};
const paidBurstingMaxIops = {
  parameterPath: ["options", "paidBurstingMaxIops"],
  mapper: {
    serializedName: "x-ms-share-paid-bursting-max-iops",
    xmlName: "x-ms-share-paid-bursting-max-iops",
    type: {
      name: "Number"
    }
  }
};
const shareProvisionedIops = {
  parameterPath: ["options", "shareProvisionedIops"],
  mapper: {
    serializedName: "x-ms-share-provisioned-iops",
    xmlName: "x-ms-share-provisioned-iops",
    type: {
      name: "Number"
    }
  }
};
const shareProvisionedBandwidthMibps = {
  parameterPath: ["options", "shareProvisionedBandwidthMibps"],
  mapper: {
    serializedName: "x-ms-share-provisioned-bandwidth-mibps",
    xmlName: "x-ms-share-provisioned-bandwidth-mibps",
    type: {
      name: "Number"
    }
  }
};
const shareSnapshot = {
  parameterPath: ["options", "shareSnapshot"],
  mapper: {
    serializedName: "sharesnapshot",
    xmlName: "sharesnapshot",
    type: {
      name: "String"
    }
  }
};
const leaseId = {
  parameterPath: ["options", "leaseAccessConditions", "leaseId"],
  mapper: {
    serializedName: "x-ms-lease-id",
    xmlName: "x-ms-lease-id",
    type: {
      name: "String"
    }
  }
};
const deleteSnapshots = {
  parameterPath: ["options", "deleteSnapshots"],
  mapper: {
    serializedName: "x-ms-delete-snapshots",
    xmlName: "x-ms-delete-snapshots",
    type: {
      name: "Enum",
      allowedValues: ["include", "include-leased"]
    }
  }
};
const comp3 = {
  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: "change",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const action3 = {
  parameterPath: "action",
  mapper: {
    defaultValue: "renew",
    isConstant: true,
    serializedName: "x-ms-lease-action",
    type: {
      name: "String"
    }
  }
};
const action4 = {
  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 comp4 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "snapshot",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const contentType1 = {
  parameterPath: ["options", "contentType"],
  mapper: {
    defaultValue: "application/json",
    isConstant: true,
    serializedName: "Content-Type",
    type: {
      name: "String"
    }
  }
};
const sharePermission = {
  parameterPath: "sharePermission",
  mapper: import_mappers.SharePermission
};
const comp5 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "filepermission",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const accept2 = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/json",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const filePermissionKey = {
  parameterPath: "filePermissionKey",
  mapper: {
    serializedName: "x-ms-file-permission-key",
    required: true,
    xmlName: "x-ms-file-permission-key",
    type: {
      name: "String"
    }
  }
};
const filePermissionFormat = {
  parameterPath: ["options", "filePermissionFormat"],
  mapper: {
    serializedName: "x-ms-file-permission-format",
    xmlName: "x-ms-file-permission-format",
    type: {
      name: "Enum",
      allowedValues: ["Sddl", "Binary"]
    }
  }
};
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 shareAcl = {
  parameterPath: ["options", "shareAcl"],
  mapper: {
    serializedName: "shareAcl",
    xmlName: "SignedIdentifiers",
    xmlIsWrapped: true,
    xmlElementName: "SignedIdentifier",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Composite",
          className: "SignedIdentifier"
        }
      }
    }
  }
};
const comp8 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "stats",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const comp9 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "undelete",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const deletedShareName = {
  parameterPath: ["options", "deletedShareName"],
  mapper: {
    serializedName: "x-ms-deleted-share-name",
    xmlName: "x-ms-deleted-share-name",
    type: {
      name: "String"
    }
  }
};
const deletedShareVersion = {
  parameterPath: ["options", "deletedShareVersion"],
  mapper: {
    serializedName: "x-ms-deleted-share-version",
    xmlName: "x-ms-deleted-share-version",
    type: {
      name: "String"
    }
  }
};
const restype2 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "directory",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const allowTrailingDot = {
  parameterPath: ["options", "allowTrailingDot"],
  mapper: {
    serializedName: "x-ms-allow-trailing-dot",
    xmlName: "x-ms-allow-trailing-dot",
    type: {
      name: "Boolean"
    }
  }
};
const filePermission = {
  parameterPath: ["options", "filePermission"],
  mapper: {
    serializedName: "x-ms-file-permission",
    xmlName: "x-ms-file-permission",
    type: {
      name: "String"
    }
  }
};
const filePermissionKey1 = {
  parameterPath: ["options", "filePermissionKey"],
  mapper: {
    serializedName: "x-ms-file-permission-key",
    xmlName: "x-ms-file-permission-key",
    type: {
      name: "String"
    }
  }
};
const fileAttributes = {
  parameterPath: ["options", "fileAttributes"],
  mapper: {
    serializedName: "x-ms-file-attributes",
    xmlName: "x-ms-file-attributes",
    type: {
      name: "String"
    }
  }
};
const fileCreatedOn = {
  parameterPath: ["options", "fileCreatedOn"],
  mapper: {
    serializedName: "x-ms-file-creation-time",
    xmlName: "x-ms-file-creation-time",
    type: {
      name: "String"
    }
  }
};
const fileLastWriteOn = {
  parameterPath: ["options", "fileLastWriteOn"],
  mapper: {
    serializedName: "x-ms-file-last-write-time",
    xmlName: "x-ms-file-last-write-time",
    type: {
      name: "String"
    }
  }
};
const fileChangeOn = {
  parameterPath: ["options", "fileChangeOn"],
  mapper: {
    serializedName: "x-ms-file-change-time",
    xmlName: "x-ms-file-change-time",
    type: {
      name: "String"
    }
  }
};
const owner = {
  parameterPath: ["options", "owner"],
  mapper: {
    serializedName: "x-ms-owner",
    xmlName: "x-ms-owner",
    type: {
      name: "String"
    }
  }
};
const group = {
  parameterPath: ["options", "group"],
  mapper: {
    serializedName: "x-ms-group",
    xmlName: "x-ms-group",
    type: {
      name: "String"
    }
  }
};
const fileMode = {
  parameterPath: ["options", "fileMode"],
  mapper: {
    serializedName: "x-ms-mode",
    xmlName: "x-ms-mode",
    type: {
      name: "String"
    }
  }
};
const filePropertySemantics = {
  parameterPath: ["options", "filePropertySemantics"],
  mapper: {
    serializedName: "x-ms-file-property-semantics",
    xmlName: "x-ms-file-property-semantics",
    type: {
      name: "String"
    }
  }
};
const include1 = {
  parameterPath: ["options", "include"],
  mapper: {
    serializedName: "include",
    xmlName: "include",
    xmlElementName: "ListFilesIncludeType",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "Enum",
          allowedValues: ["Timestamps", "Etag", "Attributes", "PermissionKey"]
        }
      }
    }
  },
  collectionFormat: "CSV"
};
const includeExtendedInfo = {
  parameterPath: ["options", "includeExtendedInfo"],
  mapper: {
    serializedName: "x-ms-file-extended-info",
    xmlName: "x-ms-file-extended-info",
    type: {
      name: "Boolean"
    }
  }
};
const comp10 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "listhandles",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const recursive = {
  parameterPath: ["options", "recursive"],
  mapper: {
    serializedName: "x-ms-recursive",
    xmlName: "x-ms-recursive",
    type: {
      name: "Boolean"
    }
  }
};
const comp11 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "forceclosehandles",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const handleId = {
  parameterPath: "handleId",
  mapper: {
    serializedName: "x-ms-handle-id",
    required: true,
    xmlName: "x-ms-handle-id",
    type: {
      name: "String"
    }
  }
};
const comp12 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "rename",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const renameSource = {
  parameterPath: "renameSource",
  mapper: {
    serializedName: "x-ms-file-rename-source",
    required: true,
    xmlName: "x-ms-file-rename-source",
    type: {
      name: "String"
    }
  }
};
const replaceIfExists = {
  parameterPath: ["options", "replaceIfExists"],
  mapper: {
    serializedName: "x-ms-file-rename-replace-if-exists",
    xmlName: "x-ms-file-rename-replace-if-exists",
    type: {
      name: "Boolean"
    }
  }
};
const ignoreReadOnly = {
  parameterPath: ["options", "ignoreReadOnly"],
  mapper: {
    serializedName: "x-ms-file-rename-ignore-readonly",
    xmlName: "x-ms-file-rename-ignore-readonly",
    type: {
      name: "Boolean"
    }
  }
};
const sourceLeaseId = {
  parameterPath: ["options", "sourceLeaseAccessConditions", "sourceLeaseId"],
  mapper: {
    serializedName: "x-ms-source-lease-id",
    xmlName: "x-ms-source-lease-id",
    type: {
      name: "String"
    }
  }
};
const destinationLeaseId = {
  parameterPath: [
    "options",
    "destinationLeaseAccessConditions",
    "destinationLeaseId"
  ],
  mapper: {
    serializedName: "x-ms-destination-lease-id",
    xmlName: "x-ms-destination-lease-id",
    type: {
      name: "String"
    }
  }
};
const fileAttributes1 = {
  parameterPath: ["options", "copyFileSmbInfo", "fileAttributes"],
  mapper: {
    serializedName: "x-ms-file-attributes",
    xmlName: "x-ms-file-attributes",
    type: {
      name: "String"
    }
  }
};
const fileCreationTime = {
  parameterPath: ["options", "copyFileSmbInfo", "fileCreationTime"],
  mapper: {
    serializedName: "x-ms-file-creation-time",
    xmlName: "x-ms-file-creation-time",
    type: {
      name: "String"
    }
  }
};
const fileLastWriteTime = {
  parameterPath: ["options", "copyFileSmbInfo", "fileLastWriteTime"],
  mapper: {
    serializedName: "x-ms-file-last-write-time",
    xmlName: "x-ms-file-last-write-time",
    type: {
      name: "String"
    }
  }
};
const fileChangeTime = {
  parameterPath: ["options", "copyFileSmbInfo", "fileChangeTime"],
  mapper: {
    serializedName: "x-ms-file-change-time",
    xmlName: "x-ms-file-change-time",
    type: {
      name: "String"
    }
  }
};
const allowSourceTrailingDot = {
  parameterPath: ["options", "allowSourceTrailingDot"],
  mapper: {
    serializedName: "x-ms-source-allow-trailing-dot",
    xmlName: "x-ms-source-allow-trailing-dot",
    type: {
      name: "Boolean"
    }
  }
};
const contentType2 = {
  parameterPath: ["options", "contentType"],
  mapper: {
    defaultValue: "application/octet-stream",
    isConstant: true,
    serializedName: "Content-Type",
    type: {
      name: "String"
    }
  }
};
const body = {
  parameterPath: ["options", "body"],
  mapper: {
    serializedName: "body",
    xmlName: "body",
    type: {
      name: "Stream"
    }
  }
};
const accept3 = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/xml",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};
const fileContentLength = {
  parameterPath: "fileContentLength",
  mapper: {
    serializedName: "x-ms-content-length",
    required: true,
    xmlName: "x-ms-content-length",
    type: {
      name: "Number"
    }
  }
};
const fileTypeConstant = {
  parameterPath: "fileTypeConstant",
  mapper: {
    defaultValue: "file",
    isConstant: true,
    serializedName: "x-ms-type",
    type: {
      name: "String"
    }
  }
};
const fileContentType = {
  parameterPath: ["options", "fileHttpHeaders", "fileContentType"],
  mapper: {
    serializedName: "x-ms-content-type",
    xmlName: "x-ms-content-type",
    type: {
      name: "String"
    }
  }
};
const fileContentEncoding = {
  parameterPath: ["options", "fileHttpHeaders", "fileContentEncoding"],
  mapper: {
    serializedName: "x-ms-content-encoding",
    xmlName: "x-ms-content-encoding",
    type: {
      name: "String"
    }
  }
};
const fileContentLanguage = {
  parameterPath: ["options", "fileHttpHeaders", "fileContentLanguage"],
  mapper: {
    serializedName: "x-ms-content-language",
    xmlName: "x-ms-content-language",
    type: {
      name: "String"
    }
  }
};
const fileCacheControl = {
  parameterPath: ["options", "fileHttpHeaders", "fileCacheControl"],
  mapper: {
    serializedName: "x-ms-cache-control",
    xmlName: "x-ms-cache-control",
    type: {
      name: "String"
    }
  }
};
const fileContentMD5 = {
  parameterPath: ["options", "fileHttpHeaders", "fileContentMD5"],
  mapper: {
    serializedName: "x-ms-content-md5",
    xmlName: "x-ms-content-md5",
    type: {
      name: "ByteArray"
    }
  }
};
const fileContentDisposition = {
  parameterPath: ["options", "fileHttpHeaders", "fileContentDisposition"],
  mapper: {
    serializedName: "x-ms-content-disposition",
    xmlName: "x-ms-content-disposition",
    type: {
      name: "String"
    }
  }
};
const nfsFileType = {
  parameterPath: ["options", "nfsFileType"],
  mapper: {
    serializedName: "x-ms-file-file-type",
    xmlName: "x-ms-file-file-type",
    type: {
      name: "String"
    }
  }
};
const contentMD5 = {
  parameterPath: ["options", "contentMD5"],
  mapper: {
    serializedName: "Content-MD5",
    xmlName: "Content-MD5",
    type: {
      name: "ByteArray"
    }
  }
};
const contentLength = {
  parameterPath: ["options", "contentLength"],
  mapper: {
    serializedName: "Content-Length",
    xmlName: "Content-Length",
    type: {
      name: "Number"
    }
  }
};
const structuredBodyType = {
  parameterPath: ["options", "structuredBodyType"],
  mapper: {
    serializedName: "x-ms-structured-body",
    xmlName: "x-ms-structured-body",
    type: {
      name: "String"
    }
  }
};
const structuredContentLength = {
  parameterPath: ["options", "structuredContentLength"],
  mapper: {
    serializedName: "x-ms-structured-content-length",
    xmlName: "x-ms-structured-content-length",
    type: {
      name: "Number"
    }
  }
};
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 fileContentLength1 = {
  parameterPath: ["options", "fileContentLength"],
  mapper: {
    serializedName: "x-ms-content-length",
    xmlName: "x-ms-content-length",
    type: {
      name: "Number"
    }
  }
};
const comp13 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "range",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const range1 = {
  parameterPath: "range",
  mapper: {
    serializedName: "x-ms-range",
    required: true,
    xmlName: "x-ms-range",
    type: {
      name: "String"
    }
  }
};
const fileRangeWrite = {
  parameterPath: "fileRangeWrite",
  mapper: {
    defaultValue: "update",
    serializedName: "x-ms-write",
    required: true,
    xmlName: "x-ms-write",
    type: {
      name: "Enum",
      allowedValues: ["update", "clear"]
    }
  }
};
const contentLength1 = {
  parameterPath: "contentLength",
  mapper: {
    serializedName: "Content-Length",
    required: true,
    xmlName: "Content-Length",
    type: {
      name: "Number"
    }
  }
};
const fileLastWrittenMode = {
  parameterPath: ["options", "fileLastWrittenMode"],
  mapper: {
    serializedName: "x-ms-file-last-write-time",
    xmlName: "x-ms-file-last-write-time",
    type: {
      name: "Enum",
      allowedValues: ["Now", "Preserve"]
    }
  }
};
const copySource = {
  parameterPath: "copySource",
  mapper: {
    serializedName: "x-ms-copy-source",
    required: true,
    xmlName: "x-ms-copy-source",
    type: {
      name: "String"
    }
  }
};
const sourceRange = {
  parameterPath: ["options", "sourceRange"],
  mapper: {
    serializedName: "x-ms-source-range",
    xmlName: "x-ms-source-range",
    type: {
      name: "String"
    }
  }
};
const fileRangeWriteFromUrl = {
  parameterPath: "fileRangeWriteFromUrl",
  mapper: {
    defaultValue: "update",
    isConstant: true,
    serializedName: "x-ms-write",
    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 sourceIfMatchCrc64 = {
  parameterPath: [
    "options",
    "sourceModifiedAccessConditions",
    "sourceIfMatchCrc64"
  ],
  mapper: {
    serializedName: "x-ms-source-if-match-crc64",
    xmlName: "x-ms-source-if-match-crc64",
    type: {
      name: "ByteArray"
    }
  }
};
const sourceIfNoneMatchCrc64 = {
  parameterPath: [
    "options",
    "sourceModifiedAccessConditions",
    "sourceIfNoneMatchCrc64"
  ],
  mapper: {
    serializedName: "x-ms-source-if-none-match-crc64",
    xmlName: "x-ms-source-if-none-match-crc64",
    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 comp14 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "rangelist",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const prevsharesnapshot = {
  parameterPath: ["options", "prevsharesnapshot"],
  mapper: {
    serializedName: "prevsharesnapshot",
    xmlName: "prevsharesnapshot",
    type: {
      name: "String"
    }
  }
};
const supportRename = {
  parameterPath: ["options", "supportRename"],
  mapper: {
    serializedName: "x-ms-file-support-rename",
    xmlName: "x-ms-file-support-rename",
    type: {
      name: "Boolean"
    }
  }
};
const filePermissionCopyMode = {
  parameterPath: ["options", "copyFileSmbInfo", "filePermissionCopyMode"],
  mapper: {
    serializedName: "x-ms-file-permission-copy-mode",
    xmlName: "x-ms-file-permission-copy-mode",
    type: {
      name: "Enum",
      allowedValues: ["source", "override"]
    }
  }
};
const ignoreReadOnly1 = {
  parameterPath: ["options", "copyFileSmbInfo", "ignoreReadOnly"],
  mapper: {
    serializedName: "x-ms-file-copy-ignore-readonly",
    xmlName: "x-ms-file-copy-ignore-readonly",
    type: {
      name: "Boolean"
    }
  }
};
const setArchiveAttribute = {
  parameterPath: ["options", "copyFileSmbInfo", "setArchiveAttribute"],
  mapper: {
    serializedName: "x-ms-file-copy-set-archive",
    xmlName: "x-ms-file-copy-set-archive",
    type: {
      name: "Boolean"
    }
  }
};
const fileModeCopyMode = {
  parameterPath: ["options", "fileModeCopyMode"],
  mapper: {
    serializedName: "x-ms-file-mode-copy-mode",
    xmlName: "x-ms-file-mode-copy-mode",
    type: {
      name: "Enum",
      allowedValues: ["source", "override"]
    }
  }
};
const fileOwnerCopyMode = {
  parameterPath: ["options", "fileOwnerCopyMode"],
  mapper: {
    serializedName: "x-ms-file-owner-copy-mode",
    xmlName: "x-ms-file-owner-copy-mode",
    type: {
      name: "Enum",
      allowedValues: ["source", "override"]
    }
  }
};
const comp15 = {
  parameterPath: "comp",
  mapper: {
    defaultValue: "copy",
    isConstant: true,
    serializedName: "comp",
    type: {
      name: "String"
    }
  }
};
const copyId = {
  parameterPath: "copyId",
  mapper: {
    serializedName: "copyid",
    required: true,
    xmlName: "copyid",
    type: {
      name: "String"
    }
  }
};
const copyActionAbortConstant = {
  parameterPath: "copyActionAbortConstant",
  mapper: {
    defaultValue: "abort",
    isConstant: true,
    serializedName: "x-ms-copy-action",
    type: {
      name: "String"
    }
  }
};
const restype3 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "symboliclink",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const linkText = {
  parameterPath: "linkText",
  mapper: {
    serializedName: "x-ms-link-text",
    required: true,
    xmlName: "x-ms-link-text",
    type: {
      name: "String"
    }
  }
};
const restype4 = {
  parameterPath: "restype",
  mapper: {
    defaultValue: "hardlink",
    isConstant: true,
    serializedName: "restype",
    type: {
      name: "String"
    }
  }
};
const targetFile = {
  parameterPath: "targetFile",
  mapper: {
    serializedName: "x-ms-file-target-file",
    required: true,
    xmlName: "x-ms-file-target-file",
    type: {
      name: "String"
    }
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  accept,
  accept1,
  accept2,
  accept3,
  accessTier,
  action,
  action1,
  action2,
  action3,
  action4,
  allowSourceTrailingDot,
  allowTrailingDot,
  body,
  breakPeriod,
  comp,
  comp1,
  comp10,
  comp11,
  comp12,
  comp13,
  comp14,
  comp15,
  comp2,
  comp3,
  comp4,
  comp5,
  comp6,
  comp7,
  comp8,
  comp9,
  contentLength,
  contentLength1,
  contentMD5,
  contentType,
  contentType1,
  contentType2,
  copyActionAbortConstant,
  copyId,
  copySource,
  copySourceAuthorization,
  deleteSnapshots,
  deletedShareName,
  deletedShareVersion,
  destinationLeaseId,
  duration,
  enableSnapshotVirtualDirectoryAccess,
  enabledProtocols,
  fileAttributes,
  fileAttributes1,
  fileCacheControl,
  fileChangeOn,
  fileChangeTime,
  fileContentDisposition,
  fileContentEncoding,
  fileContentLanguage,
  fileContentLength,
  fileContentLength1,
  fileContentMD5,
  fileContentType,
  fileCreatedOn,
  fileCreationTime,
  fileLastWriteOn,
  fileLastWriteTime,
  fileLastWrittenMode,
  fileMode,
  fileModeCopyMode,
  fileOwnerCopyMode,
  filePermission,
  filePermissionCopyMode,
  filePermissionFormat,
  filePermissionKey,
  filePermissionKey1,
  filePropertySemantics,
  fileRangeWrite,
  fileRangeWriteFromUrl,
  fileRequestIntent,
  fileTypeConstant,
  group,
  handleId,
  ignoreReadOnly,
  ignoreReadOnly1,
  include,
  include1,
  includeExtendedInfo,
  keyInfo,
  leaseId,
  leaseId1,
  linkText,
  marker,
  maxResults,
  metadata,
  nfsFileType,
  owner,
  paidBurstingEnabled,
  paidBurstingMaxBandwidthMibps,
  paidBurstingMaxIops,
  prefix,
  prevsharesnapshot,
  properties,
  proposedLeaseId,
  quota,
  range,
  range1,
  rangeGetContentMD5,
  recursive,
  renameSource,
  replaceIfExists,
  requestId,
  restype,
  restype1,
  restype2,
  restype3,
  restype4,
  rootSquash,
  setArchiveAttribute,
  shareAcl,
  sharePermission,
  shareProvisionedBandwidthMibps,
  shareProvisionedIops,
  shareSnapshot,
  sourceContentCrc64,
  sourceIfMatchCrc64,
  sourceIfNoneMatchCrc64,
  sourceLeaseId,
  sourceRange,
  structuredBodyType,
  structuredContentLength,
  supportRename,
  targetFile,
  timeoutInSeconds,
  url,
  version
});
//# sourceMappingURL=parameters.js.map
