@lindle/sharepoint_requests 0.1.19 → 0.1.20

package/dist/index.mjs

@@ -0,0 +1,863 @@
+// src/root/instance.ts
+import axios, { AxiosHeaders } from "axios";
+var defaultConfig = {
+  headers: {
+    Accept: "application/json; odata=verbose",
+    "Content-Type": "application/json; odata=verbose"
+  },
+  timeout: 15e3,
+  withCredentials: true,
+  paramsSerializer: {
+    serialize: (params) => Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k}=${String(v)}`).join("&")
+  }
+};
+var instance = (baseURL, config) => {
+  const userHeaders = (config == null ? void 0 : config.headers) instanceof AxiosHeaders ? config.headers.toJSON() : (config == null ? void 0 : config.headers) ?? {};
+  return axios.create({
+    ...defaultConfig,
+    ...config,
+    baseURL,
+    headers: {
+      ...defaultConfig.headers,
+      ...userHeaders
+    }
+  });
+};
+var instance_default = instance;
+
+// src/root/internal/digest.ts
+var cache = /* @__PURE__ */ new WeakMap();
+async function fetchDigest(instance2) {
+  var _a, _b;
+  const cached = cache.get(instance2);
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.value;
+  }
+  try {
+    const response = await instance2.post("_api/contextinfo");
+    const info = (_b = (_a = response.data) == null ? void 0 : _a.d) == null ? void 0 : _b.GetContextWebInformation;
+    const formDigestValue = info == null ? void 0 : info.FormDigestValue;
+    if (!formDigestValue) {
+      throw new Error("Invalid response structure: Missing FormDigestValue");
+    }
+    const ttl = ((info == null ? void 0 : info.FormDigestTimeoutSeconds) ?? 1800) - 60;
+    cache.set(instance2, { value: formDigestValue, expiresAt: Date.now() + ttl * 1e3 });
+    return formDigestValue;
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : "Unknown contextinfo error";
+    throw new Error(`Error retrieving Form Digest Value: ${cause}`);
+  }
+}
+
+// src/root/internal/emailRequests.ts
+async function sendEmail(context, { From, To, Subject, Body }) {
+  const response = await context.instance({
+    url: "_api/SP.Utilities.Utility.SendEmail",
+    method: "POST",
+    headers: {
+      "X-RequestDigest": await fetchDigest(context.instance),
+      "Content-Type": "application/json;odata=verbose"
+    },
+    data: JSON.stringify({
+      properties: {
+        __metadata: {
+          type: "SP.Utilities.EmailProperties"
+        },
+        From,
+        To: {
+          results: Array.isArray(To) ? To : [To]
+        },
+        Body,
+        Subject
+      }
+    })
+  });
+  return response;
+}
+
+// src/root/internal/listRequests/normalizePayload.ts
+var LOOKUP_ID_KEYS = [
+  "lookupId",
+  "LookupId",
+  "lookupID",
+  "LookupID",
+  "Id",
+  "ID"
+];
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractLookupPrimitive(value, allowGenericId) {
+  for (const key of LOOKUP_ID_KEYS) {
+    if (!allowGenericId && (key === "Id" || key === "ID")) {
+      continue;
+    }
+    if (value[key] !== void 0 && value[key] !== null) {
+      return value[key];
+    }
+  }
+  return void 0;
+}
+function normalizeLookupValue(value) {
+  if (Array.isArray(value)) {
+    return { results: value };
+  }
+  if (isPlainObject(value)) {
+    if (Array.isArray(value.results)) {
+      return { results: value.results };
+    }
+    const primitive = extractLookupPrimitive(value, true);
+    if (primitive !== void 0) {
+      return primitive;
+    }
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return value;
+    }
+    const numeric = Number(trimmed);
+    return Number.isNaN(numeric) ? trimmed : numeric;
+  }
+  return value;
+}
+function resolveLookupField(key, value) {
+  const lower = key.toLowerCase();
+  const endsWithId = lower.endsWith("id");
+  const endsWithRef = lower.endsWith("ref");
+  const endsWithLookup = lower.endsWith("lookup");
+  const hasLookupHint = endsWithId || endsWithRef || endsWithLookup;
+  if (value === void 0) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    const targetKey2 = endsWithId ? key : `${key}Id`;
+    return {
+      key: targetKey2,
+      value: { results: value }
+    };
+  }
+  if (isPlainObject(value)) {
+    const primitive = extractLookupPrimitive(value, hasLookupHint);
+    if (primitive !== void 0) {
+      const targetKey2 = endsWithId ? key : `${key}Id`;
+      return {
+        key: targetKey2,
+        value: normalizeLookupValue(primitive)
+      };
+    }
+    if (Array.isArray(value.results)) {
+      const targetKey2 = endsWithId ? key : `${key}Id`;
+      return {
+        key: targetKey2,
+        value: { results: value.results }
+      };
+    }
+    if (!hasLookupHint) {
+      return null;
+    }
+  } else if (!hasLookupHint) {
+    return null;
+  }
+  const targetKey = endsWithId ? key : `${key}Id`;
+  if (value === null) {
+    return {
+      key: targetKey,
+      value: null
+    };
+  }
+  if (typeof value === "number") {
+    return {
+      key: targetKey,
+      value
+    };
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return {
+        key: targetKey,
+        value: ""
+      };
+    }
+    const numeric = Number(trimmed);
+    return {
+      key: targetKey,
+      value: Number.isNaN(numeric) ? trimmed : numeric
+    };
+  }
+  return null;
+}
+function normalizeListPayload(data) {
+  const result = {};
+  if (!data) {
+    return result;
+  }
+  for (const [key, value] of Object.entries(data)) {
+    if (key === "__metadata") {
+      continue;
+    }
+    const lookupField = resolveLookupField(key, value);
+    if (lookupField) {
+      result[lookupField.key] = lookupField.value;
+      continue;
+    }
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/root/internal/listRequests/resolveMetadataType.ts
+async function resolveMetadataType(context) {
+  if (context.resolveListItemEntityType) {
+    return context.resolveListItemEntityType();
+  }
+  if (context.listItemEntityTypeFullName) {
+    return context.listItemEntityTypeFullName;
+  }
+  return `SP.Data.${context.listName}ListItem`;
+}
+
+// src/root/internal/listRequests/createListItem.ts
+async function createListItem(context, listData) {
+  const normalizedData = normalizeListPayload(listData);
+  let payload = normalizedData;
+  if (context.sharepointVersion === "2013") {
+    const metadataType = await resolveMetadataType(context);
+    const userMetadata = listData.__metadata;
+    payload = {
+      ...normalizedData,
+      __metadata: {
+        ...userMetadata && typeof userMetadata === "object" ? userMetadata : {},
+        type: metadataType
+      }
+    };
+  }
+  const response = await context.instance({
+    url: context.endpoint,
+    method: "POST",
+    data: JSON.stringify(payload),
+    headers: {
+      "X-RequestDigest": await fetchDigest(context.instance)
+    }
+  });
+  return response;
+}
+
+// src/root/internal/sharepointUrl.ts
+function escapeODataStringLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function buildListByTitleEndpoint(listName) {
+  return `_api/web/lists/GetByTitle('${escapeODataStringLiteral(listName)}')`;
+}
+
+// src/root/internal/listRequests/utils.ts
+function buildLibraryPath(folderPath) {
+  if (!folderPath) {
+    return "";
+  }
+  const segments = Array.isArray(folderPath) ? folderPath : folderPath.split("/").filter(Boolean);
+  if (!segments.length) {
+    return "";
+  }
+  const escapedSegments = segments.map((segment) => {
+    if (!segment.trim()) {
+      throw new Error("Folder path segments cannot be empty.");
+    }
+    const sanitized = segment.replace(/'/g, "''");
+    return `/Folders('${encodeURIComponent(sanitized)}')`;
+  });
+  return escapedSegments.join("");
+}
+function encodeFileName(fileName) {
+  if (!fileName.trim()) {
+    throw new Error("File name cannot be empty.");
+  }
+  return encodeURIComponent(fileName.replace(/'/g, "''"));
+}
+
+// src/root/internal/listRequests/createAttachment.ts
+async function createAttachment(context, { file, itemId }) {
+  if (context.sharepointVersion !== "2013") {
+    throw new Error(
+      "createAttachment is only supported for SharePoint 2013 REST endpoints."
+    );
+  }
+  const encodedFileName = encodeFileName(file.name);
+  const requestUrl = `${buildListByTitleEndpoint(
+    context.listName
+  )}/items(${itemId})/AttachmentFiles/add(FileName='${encodedFileName}')`;
+  const response = await context.instance.post(requestUrl, file, {
+    headers: {
+      "X-RequestDigest": await fetchDigest(context.instance)
+    }
+  });
+  return response;
+}
+
+// src/root/internal/listRequests/deleteItem.ts
+async function deleteItem(context, id) {
+  const requestDigest = await fetchDigest(context.instance);
+  const url = context.sharepointVersion === "2013" ? `${buildListByTitleEndpoint(context.listName)}/items(${id})` : `${context.endpoint}(${id})`;
+  const response = await context.instance.post(url, void 0, {
+    headers: {
+      "X-RequestDigest": requestDigest,
+      "IF-MATCH": "*",
+      "X-HTTP-Method": "DELETE"
+    }
+  });
+  return response;
+}
+
+// src/root/internal/listRequests/deleteFile.ts
+var SUPPORTED_VERSION = "2013";
+async function deleteFile(context, { fileName, folderPath }) {
+  if (context.sharepointVersion !== SUPPORTED_VERSION) {
+    throw new Error(
+      "deleteFile is only supported for SharePoint 2013 REST endpoints."
+    );
+  }
+  const encodedFileName = encodeFileName(fileName);
+  let requestUrl = `${buildListByTitleEndpoint(context.listName)}/RootFolder`;
+  requestUrl += buildLibraryPath(folderPath);
+  requestUrl += `/Files('${encodedFileName}')`;
+  const digest = await fetchDigest(context.instance);
+  const response = await context.instance.post(requestUrl, void 0, {
+    headers: {
+      "X-HTTP-Method": "DELETE",
+      "IF-MATCH": "*",
+      "X-RequestDigest": digest
+    }
+  });
+  return response;
+}
+
+// src/root/internal/odata.ts
+function buildODataParams(options, orderBySeparator = ",") {
+  const { expand, orderBy, limit, filter, cols, skip } = options || {};
+  const params = {
+    $expand: Array.isArray(expand) ? expand.join(",") : expand,
+    $top: limit,
+    $skip: skip,
+    $select: Array.isArray(cols) ? cols.join(",") : cols,
+    $filter: filter,
+    $orderby: Array.isArray(orderBy) ? orderBy.join(orderBySeparator) : orderBy
+  };
+  return params;
+}
+function appendParamsToUrl(baseUrl, params) {
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      baseUrl.searchParams.append(key, String(value));
+    }
+  });
+}
+
+// src/root/internal/listRequests/getFiles.ts
+async function getFiles(context, options) {
+  var _a, _b, _c;
+  const params = buildODataParams(options, ",");
+  const url = new URL(context.endpoint, context.instance.defaults.baseURL);
+  appendParamsToUrl(url, params);
+  const response = await context.instance.request({
+    url: context.endpoint,
+    method: "GET",
+    params
+  });
+  const data = ((_b = (_a = response.data) == null ? void 0 : _a.d) == null ? void 0 : _b.results) ?? ((_c = response.data) == null ? void 0 : _c.d) ?? response.data;
+  const meta = { url };
+  return { data, meta };
+}
+
+// src/root/internal/listRequests/getListItems.ts
+async function getListItems(context, options) {
+  var _a, _b, _c;
+  const params = buildODataParams(options, " ");
+  const url = new URL(context.endpoint, context.instance.defaults.baseURL);
+  appendParamsToUrl(url, params);
+  const response = await context.instance.request({
+    url: context.endpoint,
+    method: "GET",
+    params
+  });
+  const rawData = ((_b = (_a = response.data) == null ? void 0 : _a.d) == null ? void 0 : _b.results) ?? ((_c = response.data) == null ? void 0 : _c.d) ?? response.data;
+  const cols = options == null ? void 0 : options.cols;
+  const keys = cols ? (Array.isArray(cols) ? cols : [cols]).filter(
+    (key) => typeof key === "string"
+  ) : void 0;
+  const filterItem = (item) => {
+    if (!keys || !item || typeof item !== "object") {
+      return item;
+    }
+    return keys.reduce((acc, key) => {
+      if (key in item) {
+        acc[key] = item[key];
+      }
+      return acc;
+    }, {});
+  };
+  const data = Array.isArray(rawData) ? rawData.map(filterItem) : filterItem(rawData);
+  const meta = { url };
+  return {
+    data,
+    meta
+  };
+}
+
+// src/root/internal/listRequests/getOnly.ts
+async function getOnly(instance2, endpoint, options) {
+  const params = buildODataParams(options, ",");
+  const { data } = await instance2.get(endpoint, { params });
+  if (!data) {
+    return void 0;
+  }
+  if (data.d) {
+    return data.d.results ? data.d.results : data.d;
+  }
+  return data;
+}
+
+// src/root/internal/listRequests/updateListItem.ts
+async function updateListItem(context, id, data, digest) {
+  const formDigestValue = digest ?? await fetchDigest(context.instance);
+  const normalizedData = normalizeListPayload(data);
+  let payload = normalizedData;
+  if (context.sharepointVersion === "2013") {
+    const metadataType = await resolveMetadataType(context);
+    const userMetadata = data.__metadata;
+    payload = {
+      ...normalizedData,
+      __metadata: {
+        ...userMetadata && typeof userMetadata === "object" ? userMetadata : {},
+        type: metadataType
+      }
+    };
+  }
+  const url = context.sharepointVersion === "2013" ? `${buildListByTitleEndpoint(context.listName)}/items(${id})` : `${context.endpoint}(${id})`;
+  const response = await context.instance({
+    url,
+    method: "POST",
+    data: JSON.stringify(payload),
+    headers: {
+      "X-RequestDigest": formDigestValue,
+      "IF-MATCH": "*",
+      "X-HTTP-Method": "MERGE"
+    }
+  });
+  return response;
+}
+
+// src/root/internal/listRequests/uploadFile.ts
+var SUPPORTED_VERSION2 = "2013";
+async function uploadFile(context, { file, folderPath, overwrite = true }) {
+  var _a, _b, _c, _d, _e;
+  if (context.sharepointVersion !== SUPPORTED_VERSION2) {
+    throw new Error(
+      "uploadFile is only supported for SharePoint 2013 REST endpoints."
+    );
+  }
+  if (!(file == null ? void 0 : file.name)) {
+    throw new Error("A file with a valid name must be provided.");
+  }
+  let requestUrl = `${buildListByTitleEndpoint(context.listName)}/RootFolder`;
+  requestUrl += buildLibraryPath(folderPath);
+  const encodedFileName = encodeFileName(file.name);
+  requestUrl += `/Files/add(url='${encodedFileName}',overwrite=${overwrite ? "true" : "false"})?$expand=ListItemAllFields&$select=ListItemAllFields/Id`;
+  const digest = await fetchDigest(context.instance);
+  const response = await context.instance.post(requestUrl, file, {
+    headers: {
+      "Content-Type": file.type || "application/octet-stream",
+      "X-RequestDigest": digest
+    }
+  });
+  const responseData = ((_a = response.data) == null ? void 0 : _a.d) ?? response.data;
+  const listItemFields = responseData == null ? void 0 : responseData.ListItemAllFields;
+  let itemId = (listItemFields == null ? void 0 : listItemFields.Id) ?? (listItemFields == null ? void 0 : listItemFields.ID) ?? (responseData == null ? void 0 : responseData.Id) ?? (responseData == null ? void 0 : responseData.ID);
+  if (typeof itemId === "undefined" && ((_b = listItemFields == null ? void 0 : listItemFields.__deferred) == null ? void 0 : _b.uri)) {
+    const listItemResponse = await context.instance.get(
+      listItemFields.__deferred.uri
+    );
+    const deferredId = ((_d = (_c = listItemResponse.data) == null ? void 0 : _c.d) == null ? void 0 : _d.Id) ?? ((_e = listItemResponse.data) == null ? void 0 : _e.Id);
+    if (typeof deferredId !== "undefined") {
+      itemId = deferredId;
+    }
+  }
+  return { response, itemId };
+}
+
+// src/root/internal/userRequests.ts
+var PERMISSION_PRIORITY = [
+  "Full Control",
+  "Edit",
+  "Contribute",
+  "Read"
+];
+async function typeAhead(instance2, input, filter) {
+  var _a, _b, _c;
+  const requestUrl = `_api/SP.UI.ApplicationPages.ClientPeoplePickerWebServiceInterface.clientPeoplePickerSearchUser`;
+  const data = {
+    queryParams: {
+      __metadata: {
+        type: "SP.UI.ApplicationPages.ClientPeoplePickerQueryParameters"
+      },
+      AllowEmailAddresses: true,
+      AllowMultipleEntities: false,
+      AllUrlZones: false,
+      MaximumEntitySuggestions: 10,
+      PrincipalSource: 15,
+      PrincipalType: 1,
+      QueryString: input
+    }
+  };
+  if (filter) {
+    data.queryParams.RequiredProperties = [filter];
+  }
+  const response = await instance2.post(requestUrl, JSON.stringify(data), {
+    headers: {
+      Accept: "application/json; odata=verbose",
+      "Content-Type": "application/json;odata=verbose"
+    }
+  });
+  const searchResults = ((_b = (_a = response.data) == null ? void 0 : _a.d) == null ? void 0 : _b.ClientPeoplePickerSearchUser) ?? ((_c = response.data) == null ? void 0 : _c.ClientPeoplePickerSearchUser);
+  if (typeof searchResults === "string") {
+    const parsed = JSON.parse(searchResults);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      return parsed[0];
+    }
+    throw new Error("People picker returned no results.");
+  }
+  if (Array.isArray(searchResults) && searchResults.length > 0) {
+    return searchResults[0];
+  }
+  if (searchResults && typeof searchResults === "object") {
+    return searchResults;
+  }
+  throw new Error("Invalid people picker response.");
+}
+async function currentUserProperties(instance2) {
+  var _a, _b, _c;
+  const requestUrl = "_api/sp.userprofiles.peoplemanager/getmyproperties";
+  const response = await instance2.get(requestUrl);
+  const profile = ((_a = response.data) == null ? void 0 : _a.d) ?? response.data;
+  if (!profile) {
+    throw new Error("Unable to retrieve user profile.");
+  }
+  (_c = (_b = profile.UserProfileProperties) == null ? void 0 : _b.results) == null ? void 0 : _c.forEach(
+    (prop) => {
+      if (prop.Key === "FirstName") profile.FirstName = prop.Value;
+      else if (prop.Key === "LastName") profile.LastName = prop.Value;
+      else if (prop.Key === "Country") profile.Country = prop.Value;
+      else if (prop.Key === "UserName") profile.UserName = prop.Value;
+    }
+  );
+  return profile;
+}
+async function getSiteUser(instance2, searchValue) {
+  const safeSearchValue = escapeODataStringLiteral(searchValue);
+  const response = await instance2.get("_api/web/siteusers", {
+    params: {
+      $filter: `substringof('${safeSearchValue}', Title) or substringof('${safeSearchValue}', LoginName) or substringof('${safeSearchValue}', Email)`,
+      $top: 50,
+      $expand: "Groups"
+    }
+  });
+  return response.data.d;
+}
+async function roleDefinitions(instance2) {
+  const response = await instance2.get("_api/Web/RoleDefinitions");
+  return response.data.d.results;
+}
+async function getEffectiveBasePermissions(instance2) {
+  const response = await instance2.get("_api/Web/effectiveBasePermissions");
+  return response.data.d.EffectiveBasePermissions;
+}
+async function currentUserPermissions(context) {
+  const { High: userHigh, Low: userLow } = await getEffectiveBasePermissions(
+    context.instance
+  );
+  const definitions = await roleDefinitions(context.instance);
+  const userHighInt = parseInt(userHigh, 10);
+  const userLowInt = parseInt(userLow, 10);
+  const matching = definitions.filter(
+    (def) => PERMISSION_PRIORITY.includes(def.Name) && (userHighInt & parseInt(def.BasePermissions.High, 10)) === parseInt(def.BasePermissions.High, 10) && (userLowInt & parseInt(def.BasePermissions.Low, 10)) === parseInt(def.BasePermissions.Low, 10)
+  ).sort(
+    (a, b) => PERMISSION_PRIORITY.indexOf(a.Name) - PERMISSION_PRIORITY.indexOf(b.Name)
+  );
+  const result = matching[0];
+  if (!result) {
+    throw new Error(
+      `Unable to resolve current user permission. Effective: High="${userHigh}", Low="${userLow}"`
+    );
+  }
+  return result;
+}
+
+// src/root/index.ts
+var HTTPSharePointRequests = class {
+  baseURL;
+  instance;
+  listItemEntityTypeCache;
+  /**
+   * @deprecated SP.Utilities.Utility.SendEmail was retired by Microsoft on 2025-10-31.
+   * Migrate to Microsoft Graph API POST /v1.0/me/sendMail
+   * https://learn.microsoft.com/en-us/graph/api/user-sendmail
+   */
+  email;
+  constructor(baseURL, config) {
+    this.baseURL = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+    this.instance = instance_default(this.baseURL, config);
+    this.listItemEntityTypeCache = /* @__PURE__ */ new Map();
+    const buildEmailContext = () => this.createContext({
+      endpoint: "_api/SP.Utilities.Utility.SendEmail",
+      listName: "",
+      sharepointVersion: "2013"
+    });
+    this.email = Object.assign(
+      (from, to, subject, body) => sendEmail(buildEmailContext(), {
+        From: from,
+        To: to,
+        Subject: subject,
+        Body: body
+      }),
+      {
+        send: (props) => sendEmail(buildEmailContext(), props)
+      }
+    );
+  }
+  createContext({
+    endpoint,
+    listName,
+    sharepointVersion,
+    listItemEntityTypeFullName,
+    resolveListItemEntityType
+  }) {
+    return {
+      instance: this.instance,
+      endpoint,
+      listName,
+      sharepointVersion,
+      listItemEntityTypeFullName,
+      resolveListItemEntityType
+    };
+  }
+  async resolveListItemEntityTypeFullName(listName) {
+    var _a, _b, _c;
+    const cacheKey = listName;
+    const cachedType = this.listItemEntityTypeCache.get(cacheKey);
+    if (cachedType) {
+      return cachedType;
+    }
+    const response = await this.instance.get(
+      `${buildListByTitleEndpoint(listName)}?$select=ListItemEntityTypeFullName`
+    );
+    const entityType = ((_b = (_a = response.data) == null ? void 0 : _a.d) == null ? void 0 : _b.ListItemEntityTypeFullName) ?? ((_c = response.data) == null ? void 0 : _c.ListItemEntityTypeFullName);
+    if (!entityType || typeof entityType !== "string") {
+      throw new Error(
+        `Unable to resolve ListItemEntityTypeFullName for list "${listName}".`
+      );
+    }
+    this.listItemEntityTypeCache.set(cacheKey, entityType);
+    return entityType;
+  }
+  buildListScope(listName, version) {
+    const listNameValue = String(listName);
+    const endpoint = version === "2013" ? `${buildListByTitleEndpoint(listNameValue)}/items` : `_vti_bin/ListData.svc/${encodeURIComponent(listNameValue)}`;
+    let scopedEntityType;
+    const resolveListItemEntityType = async () => {
+      if (scopedEntityType) {
+        return scopedEntityType;
+      }
+      if (version !== "2013") {
+        scopedEntityType = `SP.Data.${listNameValue}ListItem`;
+        return scopedEntityType;
+      }
+      scopedEntityType = await this.resolveListItemEntityTypeFullName(
+        listNameValue
+      );
+      return scopedEntityType;
+    };
+    const getContext = () => this.createContext({
+      endpoint,
+      listName: listNameValue,
+      sharepointVersion: version,
+      listItemEntityTypeFullName: scopedEntityType,
+      resolveListItemEntityType
+    });
+    const removeItem = (id) => deleteItem(getContext(), id);
+    const removeFile = (props) => deleteFile(getContext(), props);
+    return {
+      create: (data) => createListItem(getContext(), data),
+      get: (options) => getListItems(getContext(), options),
+      update: (id, data, digest) => updateListItem(getContext(), id, data, digest),
+      delete: removeItem,
+      remove: removeItem,
+      createFile: (props) => createAttachment(getContext(), props),
+      uploadFile: (props) => uploadFile(getContext(), props),
+      deleteFile: removeFile,
+      removeFile,
+      fields: (options) => {
+        const fieldsEndpoint = !(options == null ? void 0 : options.fieldName) ? `${buildListByTitleEndpoint(listNameValue)}/fields` : `${buildListByTitleEndpoint(
+          listNameValue
+        )}/fields/getbytitle('${escapeODataStringLiteral(
+          String(options.fieldName)
+        )}')`;
+        return {
+          get: () => getOnly(this.instance, fieldsEndpoint, options)
+        };
+      },
+      items: {
+        create: (data) => createListItem(getContext(), data),
+        get: (options) => getListItems(getContext(), options),
+        update: (id, data, digest) => updateListItem(getContext(), id, data, digest),
+        delete: removeItem,
+        remove: removeItem
+      },
+      files: {
+        attach: (props) => createAttachment(getContext(), props),
+        upload: (props) => uploadFile(getContext(), props),
+        delete: removeFile,
+        remove: removeFile
+      }
+    };
+  }
+  /**
+   * @deprecated Use `from(listName, '2010')` instead.
+   */
+  list(listName) {
+    return this.from(listName, "2010");
+  }
+  from(listName, sharepointVersion) {
+    const version = sharepointVersion ?? "2013";
+    return this.buildListScope(listName, version);
+  }
+  field(listName, fieldName, sharepointVersion) {
+    return this.from(listName, sharepointVersion).fields({
+      fieldName
+    }).get();
+  }
+  lists(options) {
+    const context = this.createContext({
+      endpoint: "_api/web/lists",
+      listName: "",
+      sharepointVersion: "2013"
+    });
+    return {
+      get: () => getListItems(context, options)
+    };
+  }
+  getDigest() {
+    return fetchDigest(this.instance);
+  }
+  folders(options) {
+    const context = this.createContext({
+      endpoint: "_api/web/folders",
+      listName: "",
+      sharepointVersion: "2013"
+    });
+    return {
+      get: () => getFiles(context, options)
+    };
+  }
+  folder(folderName) {
+    const defaultPath = ["Shared Documents"];
+    const segments = folderName ? Array.isArray(folderName) ? [...defaultPath, ...folderName] : [...defaultPath, ...folderName.split("/").filter(Boolean)] : defaultPath;
+    const serverRelativePath = escapeODataStringLiteral(segments.join("/"));
+    const baseEndpoint = `_api/web/GetFolderByServerRelativeUrl('${serverRelativePath}')`;
+    return {
+      get: (options) => {
+        const folderType = (options == null ? void 0 : options.type) ?? "Files";
+        const endpoint = `${baseEndpoint}/${folderType}`;
+        const context = this.createContext({
+          endpoint,
+          listName: "",
+          sharepointVersion: "2013"
+        });
+        return getFiles(context, {
+          ...options,
+          type: folderType
+        });
+      }
+    };
+  }
+  users(options) {
+    const context = this.createContext({
+      endpoint: "_api/web/SiteUserInfoList/items",
+      listName: "",
+      sharepointVersion: "2013"
+    });
+    return {
+      get: () => getListItems(context, options)
+    };
+  }
+  /**
+   * @deprecated SP.Utilities.Utility.SendEmail was retired by Microsoft on 2025-10-31.
+   * Migrate to Microsoft Graph API POST /v1.0/me/sendMail
+   * https://learn.microsoft.com/en-us/graph/api/user-sendmail
+   */
+  sendEmail(props) {
+    const context = this.createContext({
+      endpoint: "_api/SP.Utilities.Utility.SendEmail",
+      listName: "",
+      sharepointVersion: "2013"
+    });
+    return sendEmail(context, props);
+  }
+  user = {
+    properties: () => ({
+      get: () => currentUserProperties(this.instance)
+    }),
+    searchSiteUser: (searchValue) => getSiteUser(this.instance, searchValue),
+    searchUser: (input, filter) => typeAhead(this.instance, input, filter),
+    current: () => ({
+      get: () => getOnly(this.instance, "_api/web/currentUser")
+    }),
+    currentPermission: () => ({
+      get: () => currentUserPermissions(
+        this.createContext({
+          endpoint: "_api/web/effectiveBasePermissions",
+          listName: "",
+          sharepointVersion: "2013"
+        })
+      )
+    })
+  };
+  getCurrentUser() {
+    return this.user.current().get();
+  }
+  currentUserProperties() {
+    return this.user.properties().get();
+  }
+  currentUserPermission() {
+    return this.user.currentPermission().get();
+  }
+};
+var root_default = HTTPSharePointRequests;
+
+// src/index.ts
+function createBase() {
+  function create({
+    baseURL,
+    config
+  }) {
+    if (!baseURL) {
+      throw new Error("A valid SharePoint URL must be provided.");
+    }
+    return new root_default(baseURL, config);
+  }
+  return {
+    /**
+     * @deprecated Use `create` instead.
+     */
+    baseURL(url, config) {
+      return create({ baseURL: url, config });
+    },
+    create
+  };
+}
+export {
+  createBase as default
+};
+//# sourceMappingURL=index.mjs.map