microsoft-graph 2.2.5 → 2.3.0

package/dist/errors/NeverError.d.ts

@@ -1,4 +1,4 @@
 export default class NeverError extends Error {
-    constructor(message: string);
+    constructor(message?: string);
 }
 //# sourceMappingURL=NeverError.d.ts.map

package/dist/errors/NeverError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NeverError.d.ts","sourceRoot":"","sources":["../../src/errors/NeverError.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAIlC"}
+{"version":3,"file":"NeverError.d.ts","sourceRoot":"","sources":["../../src/errors/NeverError.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAInC"}

package/dist/errors/UnsupportedAddressTypeError.d.ts

@@ -0,0 +1,4 @@
+export default class UnsupportedAddressTypeError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=UnsupportedAddressTypeError.d.ts.map

package/dist/errors/UnsupportedAddressTypeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnsupportedAddressTypeError.d.ts","sourceRoot":"","sources":["../../src/errors/UnsupportedAddressTypeError.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,2BAA4B,SAAQ,KAAK;gBAC1C,OAAO,EAAE,MAAM;CAIlC"}

package/dist/errors/UnsupportedAddressTypeError.js

@@ -0,0 +1,6 @@
+export default class UnsupportedAddressTypeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnsupportedAddressTypeError";
+    }
+}

package/dist/models/ColumnOffset.d.ts

@@ -0,0 +1,4 @@
+export type ColumnOffset = number & {
+    __brand: "ColumnOffset";
+};
+//# sourceMappingURL=ColumnOffset.d.ts.map

package/dist/models/ColumnOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnOffset.d.ts","sourceRoot":"","sources":["../../src/models/ColumnOffset.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IACnC,OAAO,EAAE,cAAc,CAAC;CACxB,CAAC"}

package/dist/models/ColumnOffset.js

@@ -0,0 +1 @@
+export {};

package/dist/models/RowOffset.d.ts

@@ -0,0 +1,4 @@
+export type RowOffset = number & {
+    __brand: "RowOffset";
+};
+//# sourceMappingURL=RowOffset.d.ts.map

package/dist/models/RowOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowOffset.d.ts","sourceRoot":"","sources":["../../src/models/RowOffset.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAChC,OAAO,EAAE,WAAW,CAAC;CACrB,CAAC"}

package/dist/models/RowOffset.js

@@ -0,0 +1 @@
+export {};

package/dist/operations/drive/listDrives.d.ts

@@ -3,5 +3,5 @@ import type { DriveRef } from "../../models/DriveRef.ts";
 import type { GraphOperation } from "../../models/GraphOperation.ts";
 import type { SiteRef } from "../../models/SiteRef.ts";
 /** Retrieve the list of Drive resources available for a Site. @see https://learn.microsoft.com/en-us/graph/api/drive-list */
-export default function listDrives(siteRef?: SiteRef): GraphOperation<(DriveItem & DriveRef)[]>;
+export default function listDrives(siteRef: SiteRef): GraphOperation<(DriveItem & DriveRef)[]>;
 //# sourceMappingURL=listDrives.d.ts.map

package/dist/operations/drive/listDrives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"listDrives.d.ts","sourceRoot":"","sources":["../../../src/operations/drive/listDrives.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAKvD,6HAA6H;AAC7H,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,OAAO,GAAE,OAA6B,GAAG,cAAc,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAC,EAAE,CAAC,CAkBnH"}
+{"version":3,"file":"listDrives.d.ts","sourceRoot":"","sources":["../../../src/operations/drive/listDrives.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAIvD,6HAA6H;AAC7H,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAC,EAAE,CAAC,CAkB7F"}

package/dist/operations/drive/listDrives.js

@@ -1,9 +1,8 @@
 import { operation } from "../../graphApi.js";
 import { createDriveRef } from "../../services/drive.js";
-import { getDefaultSiteRef } from "../../services/site.js";
 import { generatePath } from "../../services/templatedPaths.js";
 /** Retrieve the list of Drive resources available for a Site. @see https://learn.microsoft.com/en-us/graph/api/drive-list */
-export default function listDrives(siteRef = getDefaultSiteRef()) {
+export default function listDrives(siteRef) {
     return operation({
         contextId: siteRef.contextId,
         method: "GET",

package/dist/operations/drive/listDrives.test.js

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
+import { getDefaultSiteRef } from "../../services/site.js";
 import listDrives from "./listDrives.js";
 describe("listDrives", () => {
     it("can listDrives", async () => {
-        const drives = await listDrives();
+        const siteRef = getDefaultSiteRef();
+        const drives = await listDrives(siteRef);
         console.debug("Drives:", drives.map((drive) => [drive.id, drive.name]));
         expect(drives.length).toBeGreaterThan(0);
     });

package/dist/services/addressManipulation.d.ts

@@ -0,0 +1,20 @@
+import type { Address, CellAddress, ColumnAddress, RowAddress } from "../models/Address.ts";
+export type AddressComponents = {
+    startColumn: ColumnAddress;
+    endColumn: ColumnAddress;
+    startRow: RowAddress;
+    endRow: RowAddress;
+};
+export declare function decomposeAddress(address: Address): AddressComponents;
+export declare function composeAddress(components: AddressComponents): Address;
+export declare function getFirstCellAddress(address: Address): CellAddress;
+export declare function getLastCellAddress(address: Address): CellAddress;
+export declare function getFirstRowAddress(address: Address): Address;
+export declare function getLastRowAddress(address: Address): Address;
+export declare function getFirstColumnAddress(address: Address): Address;
+export declare function getLastColumnAddress(address: Address): Address;
+export declare function offsetAddress(address: Address, columnOffset: number, rowOffset: number): Address;
+export declare function incrementRowAddress(address: Address): Address;
+export declare function decrementRowAddress(address: Address): Address;
+export declare function isAddressOverlapping(address1: Address, address2: Address): boolean;
+//# sourceMappingURL=addressManipulation.d.ts.map

package/dist/services/addressManipulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressManipulation.d.ts","sourceRoot":"","sources":["../../src/services/addressManipulation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAoB,aAAa,EAAsB,UAAU,EAAmB,MAAM,sBAAsB,CAAC;AAmBnJ,MAAM,MAAM,iBAAiB,GAAG;IAC/B,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,UAAU,CAAC;IACrB,MAAM,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAcpE;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CA6BrE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAGjE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAGhE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS5D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS3D;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS/D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAS9D;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAqChG;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAKlF"}

package/dist/services/addressManipulation.js

@@ -0,0 +1,159 @@
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+import UnsupportedAddressTypeError from "../errors/UnsupportedAddressTypeError.js";
+import { columnAddressToOffset, offsetToColumnAddress, offsetToRowAddress, rowAddressToOffset } from "./addressOffset.js";
+const firstColumn = "A";
+const lastColumn = "XFD";
+const firstRow = "1";
+const lastRow = "1048576";
+const addressPattern = /^(?<sheet>[A-Za-z0-9_]+!)?(?:(?<startColumn>[A-Z]+)?(?<startRow>\d+)?(?::(?<endColumn>[A-Z]+)?(?<endRow>\d+)?)?)$/;
+export function decomposeAddress(address) {
+    const match = address.match(addressPattern);
+    if (!match?.groups) {
+        throw new InvalidArgumentError(`Invalid address format. Must match pattern '${addressPattern}'`);
+    }
+    const groups = match.groups;
+    return {
+        startColumn: groups.startColumn ?? firstColumn,
+        startRow: groups.startRow ?? firstRow,
+        endColumn: groups.endColumn ?? groups.startColumn ?? lastColumn,
+        endRow: groups.endRow ?? groups.startRow ?? lastRow,
+    };
+}
+export function composeAddress(components) {
+    if (isSingleColumn(components) && isMaxRows(components)) {
+        return composeColumnAddress(components.startColumn);
+    }
+    if (isSingleRow(components) && isMaxColumns(components)) {
+        return composeRowAddress(components.startRow);
+    }
+    if (isMaxRows(components)) {
+        return composeColumnRangeAddress(components.startColumn, components.endColumn);
+    }
+    if (isMaxColumns(components)) {
+        return composeRowRangeAddress(components.startRow, components.endRow);
+    }
+    if (isSingleColumn(components) && isSingleRow(components)) {
+        return composeCellAddress(components.startColumn, components.startRow);
+    }
+    if (components.startColumn > components.endColumn) {
+        throw new InvalidArgumentError("Invalid address. End column is before start column.");
+    }
+    if (components.startRow > components.endRow) {
+        throw new InvalidArgumentError("Invalid address. End row is before start row.");
+    }
+    return composeCellRangeAddress(components.startColumn, components.startRow, components.endColumn, components.endRow);
+}
+export function getFirstCellAddress(address) {
+    const components = decomposeAddress(address);
+    return composeCellAddress(components.startColumn, components.startRow);
+}
+export function getLastCellAddress(address) {
+    const components = decomposeAddress(address);
+    return composeCellAddress(components.endColumn, components.endRow);
+}
+export function getFirstRowAddress(address) {
+    const components = decomposeAddress(address);
+    return composeAddress({
+        startColumn: components.startColumn,
+        startRow: components.startRow,
+        endColumn: components.endColumn,
+        endRow: components.startRow,
+    });
+}
+export function getLastRowAddress(address) {
+    const components = decomposeAddress(address);
+    return composeAddress({
+        startColumn: components.startColumn,
+        startRow: components.endRow,
+        endColumn: components.endColumn,
+        endRow: components.endRow,
+    });
+}
+export function getFirstColumnAddress(address) {
+    const components = decomposeAddress(address);
+    return composeAddress({
+        startColumn: components.startColumn,
+        startRow: components.startRow,
+        endColumn: components.startColumn,
+        endRow: components.endRow,
+    });
+}
+export function getLastColumnAddress(address) {
+    const components = decomposeAddress(address);
+    return composeAddress({
+        startColumn: components.endColumn,
+        startRow: components.startRow,
+        endColumn: components.endColumn,
+        endRow: components.endRow,
+    });
+}
+export function offsetAddress(address, columnOffset, rowOffset) {
+    const components = decomposeAddress(address);
+    if (isMaxRows(components) && rowOffset !== 0) {
+        throw new UnsupportedAddressTypeError("All rows are selected. Cannot offset rows.");
+    }
+    if (isMaxColumns(components) && columnOffset !== 0) {
+        throw new UnsupportedAddressTypeError("All columns are selected. Cannot offset columns.");
+    }
+    const newStartRowIndex = rowAddressToOffset(components.startRow) + rowOffset;
+    const newEndRowIndex = rowAddressToOffset(components.endRow) + rowOffset;
+    if (newStartRowIndex < rowAddressToOffset(firstRow) || newEndRowIndex > rowAddressToOffset(lastRow)) {
+        throw new InvalidArgumentError(`Row offset out of bounds: ${newStartRowIndex + 1} to ${newEndRowIndex + 1}`);
+    }
+    const newStartRow = offsetToRowAddress(newStartRowIndex);
+    const newEndRow = offsetToRowAddress(newEndRowIndex);
+    const newStartColumnIndex = columnAddressToOffset(components.startColumn) + columnOffset;
+    const newEndColumnIndex = columnAddressToOffset(components.endColumn) + columnOffset;
+    if (newStartColumnIndex < columnAddressToOffset(firstColumn) || newEndColumnIndex > columnAddressToOffset(lastColumn)) {
+        throw new InvalidArgumentError(`Column offset out of bounds: ${newStartColumnIndex + 1} to ${newEndColumnIndex + 1}`);
+    }
+    const newStartColumn = offsetToColumnAddress(newStartColumnIndex);
+    const newEndColumn = offsetToColumnAddress(newEndColumnIndex);
+    return composeAddress({
+        startColumn: newStartColumn,
+        endColumn: newEndColumn,
+        startRow: newStartRow,
+        endRow: newEndRow,
+    });
+}
+export function incrementRowAddress(address) {
+    return offsetAddress(address, 0, +1);
+}
+export function decrementRowAddress(address) {
+    return offsetAddress(address, 0, -1);
+}
+export function isAddressOverlapping(address1, address2) {
+    const components1 = decomposeAddress(address1);
+    const components2 = decomposeAddress(address2);
+    return components1.startColumn <= components2.endColumn && components1.endColumn >= components2.startColumn && rowAddressToOffset(components1.startRow) <= rowAddressToOffset(components2.endRow) && rowAddressToOffset(components1.endRow) >= rowAddressToOffset(components2.startRow);
+}
+function composeCellRangeAddress(startColumn, startRow, endColumn, endRow) {
+    return `${startColumn}${startRow}:${endColumn}${endRow}`;
+}
+function composeCellAddress(startColumn, startRow) {
+    return `${startColumn}${startRow}`;
+}
+function composeRowRangeAddress(startRow, endRow) {
+    return `${startRow}:${endRow}`;
+}
+function composeColumnRangeAddress(startColumn, endColumn) {
+    return `${startColumn}:${endColumn}`;
+}
+function composeRowAddress(startRow) {
+    return startRow;
+}
+function composeColumnAddress(startColumn) {
+    return startColumn;
+}
+function isSingleRow(components) {
+    return components.startRow === components.endRow;
+}
+function isSingleColumn(components) {
+    return components.startColumn === components.endColumn;
+}
+function isMaxColumns(components) {
+    return components.startColumn === firstColumn && components.endColumn === lastColumn;
+}
+function isMaxRows(components) {
+    return components.startRow === firstRow && components.endRow === lastRow;
+}

package/dist/services/addressManipulation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=addressManipulation.test.d.ts.map

package/dist/services/addressManipulation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressManipulation.test.d.ts","sourceRoot":"","sources":["../../src/services/addressManipulation.test.ts"],"names":[],"mappings":""}

package/dist/services/addressManipulation.test.js

@@ -0,0 +1,310 @@
+import { describe, expect, it } from "vitest";
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+import { composeAddress, decomposeAddress, decrementRowAddress, getFirstCellAddress, getFirstColumnAddress, getFirstRowAddress, getLastCellAddress, getLastColumnAddress, getLastRowAddress, incrementRowAddress, isAddressOverlapping, offsetAddress } from "./addressManipulation.js";
+describe("getFirstCellAddress", () => {
+    it("should return the start cell of a range address", () => {
+        expect(getFirstCellAddress("C3:D4")).toBe("C3");
+        expect(getFirstCellAddress("Sheet!A1:B2")).toBe("A1");
+        expect(getFirstCellAddress("E5")).toBe("E5"); // Single cell address
+        expect(getFirstCellAddress("Sheet!E5")).toBe("E5"); // Single cell address
+        expect(getFirstCellAddress("C")).toBe("C1"); // ColumnAddress
+        expect(getFirstCellAddress("Sheet!C")).toBe("C1"); // ColumnAddress
+        expect(getFirstCellAddress("3")).toBe("A3"); // RowAddress
+        expect(getFirstCellAddress("Sheet!3")).toBe("A3"); // RowAddress
+        expect(getFirstCellAddress("A:Z")).toBe("A1"); // ColumnRangeAddress
+        expect(getFirstCellAddress("Sheet!A:Z")).toBe("A1"); // ColumnRangeAddress
+        expect(getFirstCellAddress("1:10")).toBe("A1"); // RowRangeAddress
+        expect(getFirstCellAddress("Sheet!1:10")).toBe("A1"); // RowRangeAddress
+    });
+});
+describe("getLastCellAddress", () => {
+    it("should return the end cell of a range address", () => {
+        expect(getLastCellAddress("C3:D4")).toBe("D4");
+        expect(getLastCellAddress("Sheet!A1:B2")).toBe("B2");
+        expect(getLastCellAddress("E5")).toBe("E5"); // Single cell address
+        expect(getLastCellAddress("Sheet!E5")).toBe("E5"); // Single cell address
+        expect(getLastCellAddress("C")).toBe("C1048576"); // ColumnAddress
+        expect(getLastCellAddress("Sheet!C")).toBe("C1048576"); // ColumnAddress
+        expect(getLastCellAddress("3")).toBe("XFD3"); // RowAddress
+        expect(getLastCellAddress("Sheet!3")).toBe("XFD3"); // RowAddress
+        expect(getLastCellAddress("A:Z")).toBe("Z1048576"); // ColumnRangeAddress
+        expect(getLastCellAddress("Sheet!A:Z")).toBe("Z1048576"); // ColumnRangeAddress
+        expect(getLastCellAddress("1:10")).toBe("XFD10"); // RowRangeAddress
+        expect(getLastCellAddress("Sheet!1:10")).toBe("XFD10"); // RowRangeAddress
+    });
+});
+describe("getFirstRowAddress", () => {
+    it("should return the first row of a row range", () => {
+        expect(getFirstRowAddress("1:5")).toBe("1");
+        expect(getFirstRowAddress("Sheet!1:10")).toBe("1");
+    });
+    it("should return the first row of a column range", () => {
+        expect(getFirstRowAddress("A")).toBe("A1");
+        expect(getFirstRowAddress("A:C")).toBe("A1:C1");
+    });
+    it("should handle cell ranges", () => {
+        expect(getFirstRowAddress("A1:C5")).toBe("A1:C1");
+    });
+    it("should return the first row of a single cell address", () => {
+        expect(getFirstRowAddress("A1")).toBe("A1");
+        expect(getFirstRowAddress("Sheet!B2")).toBe("B2");
+    });
+    it("should handle cell ranges", () => {
+        expect(getFirstRowAddress("A1:C5")).toBe("A1:C1");
+    });
+    it("should return the same cell address for a single cell", () => {
+        expect(getFirstRowAddress("C1")).toBe("C1");
+    });
+});
+describe("getLastRowAddress", () => {
+    it("should return the last row of a row range", () => {
+        expect(getLastRowAddress("1:5")).toBe("5");
+        expect(getLastRowAddress("Sheet!1:10")).toBe("10");
+    });
+    it("should return the last row of a column range", () => {
+        expect(getLastRowAddress("A")).toBe("A1048576");
+        expect(getLastRowAddress("A:C")).toBe("A1048576:C1048576");
+    });
+    it("should handle cell ranges", () => {
+        expect(getLastRowAddress("A1:C5")).toBe("A5:C5");
+    });
+    it("should return the last row of a single cell address", () => {
+        expect(getLastRowAddress("A1")).toBe("A1");
+        expect(getLastRowAddress("Sheet!B2")).toBe("B2");
+    });
+    it("should handle cell ranges", () => {
+        expect(getLastRowAddress("A1:C5")).toBe("A5:C5");
+    });
+    it("should return the same cell address for a single cell", () => {
+        expect(getLastRowAddress("C1")).toBe("C1");
+    });
+});
+describe("getFirstColumnAddress", () => {
+    it("should return the first column of a column range", () => {
+        expect(getFirstColumnAddress("A:C")).toBe("A");
+        expect(getFirstColumnAddress("Sheet!A:Z")).toBe("A");
+    });
+    it("should return the first column of a row range", () => {
+        expect(getFirstColumnAddress("1")).toBe("A1");
+        expect(getFirstColumnAddress("1:5")).toBe("A1:A5");
+    });
+    it("should handle cell ranges", () => {
+        expect(getFirstColumnAddress("A1:C5")).toBe("A1:A5");
+    });
+    it("should return the first column of a single cell address", () => {
+        expect(getFirstColumnAddress("A1")).toBe("A1");
+        expect(getFirstColumnAddress("Sheet!B2")).toBe("B2");
+    });
+    it("should handle cell ranges", () => {
+        expect(getFirstColumnAddress("A1:C5")).toBe("A1:A5");
+    });
+    it("should return the same cell address for a single cell", () => {
+        expect(getFirstColumnAddress("C1")).toBe("C1");
+    });
+});
+describe("getLastColumnAddress", () => {
+    it("should return the last column of a column range", () => {
+        expect(getLastColumnAddress("A:C")).toBe("C");
+        expect(getLastColumnAddress("Sheet!A:Z")).toBe("Z");
+    });
+    it("should return the last column of a row range", () => {
+        expect(getLastColumnAddress("1")).toBe("XFD1");
+        expect(getLastColumnAddress("1:5")).toBe("XFD1:XFD5");
+    });
+    it("should handle cell ranges", () => {
+        expect(getLastColumnAddress("A1:C5")).toBe("C1:C5");
+    });
+    it("should return the last column of a single cell address", () => {
+        expect(getLastColumnAddress("A1")).toBe("A1");
+        expect(getLastColumnAddress("Sheet!B2")).toBe("B2");
+    });
+    it("should handle cell ranges", () => {
+        expect(getLastColumnAddress("A1:C5")).toBe("C1:C5");
+    });
+    it("should return the same cell address for a single cell", () => {
+        expect(getLastColumnAddress("C1")).toBe("C1");
+    });
+});
+describe("offsetAddress", () => {
+    it("should offset rows and columns in a cell range", () => {
+        expect(offsetAddress("A1:C5", 2, 2)).toBe("C3:E7");
+        expect(offsetAddress("Sheet!B2:C5", 2, 2)).toBe("D4:E7");
+    });
+    it("should offset rows only", () => {
+        expect(offsetAddress("A1:C5", 0, 2)).toBe("A3:C7");
+        expect(offsetAddress("Sheet!B1:C5", 0, 2)).toBe("B3:C7");
+    });
+    it("should offset columns only", () => {
+        expect(offsetAddress("A1:C5", 2, 0)).toBe("C1:E5");
+        expect(offsetAddress("Sheet!A2:C5", 2, 0)).toBe("C2:E5");
+    });
+    it("should throw if offset exceeds valid range", () => {
+        expect(() => offsetAddress("A1:C5", 0, 1048577)).toThrow(InvalidArgumentError);
+        expect(() => offsetAddress("A1:C5", 16385, 0)).toThrow(InvalidArgumentError);
+    });
+    it("should offset rows and columns in a single cell address", () => {
+        expect(offsetAddress("A1", 2, 2)).toBe("C3");
+        expect(offsetAddress("Sheet!B2", 2, 2)).toBe("D4");
+    });
+});
+describe("incrementRowAddress", () => {
+    it("should increment the row of a row range", () => {
+        expect(incrementRowAddress("1:5")).toBe("2:6");
+    });
+    it("should increment the row of a cell range", () => {
+        expect(incrementRowAddress("A1:C5")).toBe("A2:C6");
+    });
+});
+describe("decrementRowAddress", () => {
+    it("should decrement the row of a row range", () => {
+        expect(decrementRowAddress("2:6")).toBe("1:5");
+    });
+    it("should decrement the row of a cell range", () => {
+        expect(decrementRowAddress("A2:C6")).toBe("A1:C5");
+    });
+});
+describe("decomposeAddress", () => {
+    it("should parse a column address", () => {
+        expect(decomposeAddress("A")).toEqual({
+            startColumn: "A",
+            endColumn: "A",
+            startRow: "1",
+            endRow: "1048576",
+        });
+    });
+    it("should parse a row address", () => {
+        expect(decomposeAddress("5")).toEqual({
+            startColumn: "A",
+            endColumn: "XFD",
+            startRow: "5",
+            endRow: "5",
+        });
+    });
+    it("should parse a cell address", () => {
+        expect(decomposeAddress("B3")).toEqual({
+            startColumn: "B",
+            endColumn: "B",
+            startRow: "3",
+            endRow: "3",
+        });
+    });
+    it("should parse a column range address", () => {
+        expect(decomposeAddress("A:C")).toEqual({
+            startColumn: "A",
+            endColumn: "C",
+            startRow: "1",
+            endRow: "1048576",
+        });
+    });
+    it("should parse a row range address", () => {
+        expect(decomposeAddress("1:10")).toEqual({
+            startColumn: "A",
+            endColumn: "XFD",
+            startRow: "1",
+            endRow: "10",
+        });
+    });
+    it("should parse a cell range address", () => {
+        expect(decomposeAddress("A1:C5")).toEqual({
+            startColumn: "A",
+            endColumn: "C",
+            startRow: "1",
+            endRow: "5",
+        });
+    });
+    it("should throw an error for invalid addresses", () => {
+        expect(() => decomposeAddress("InvalidAddress")).toThrow(InvalidArgumentError);
+    });
+});
+describe("composeAddress", () => {
+    it("should create a column address", () => {
+        expect(composeAddress({
+            startColumn: "A",
+            endColumn: "A",
+            startRow: "1",
+            endRow: "1048576",
+        })).toBe("A");
+    });
+    it("should create a row address", () => {
+        expect(composeAddress({
+            startColumn: "A",
+            endColumn: "XFD",
+            startRow: "5",
+            endRow: "5",
+        })).toBe("5");
+    });
+    it("should create a cell address", () => {
+        expect(composeAddress({
+            startColumn: "B",
+            endColumn: "B",
+            startRow: "3",
+            endRow: "3",
+        })).toBe("B3");
+    });
+    it("should create a column range address", () => {
+        expect(composeAddress({
+            startColumn: "A",
+            endColumn: "C",
+            startRow: "1",
+            endRow: "1048576",
+        })).toBe("A:C");
+    });
+    it("should create a row range address", () => {
+        expect(composeAddress({
+            startColumn: "A",
+            endColumn: "XFD",
+            startRow: "1",
+            endRow: "10",
+        })).toBe("1:10");
+    });
+    it("should create a cell range address", () => {
+        expect(composeAddress({
+            startColumn: "A",
+            endColumn: "C",
+            startRow: "1",
+            endRow: "5",
+        })).toBe("A1:C5");
+    });
+    it("should throw an error for invalid address components", () => {
+        expect(() => composeAddress({
+            startColumn: "C",
+            endColumn: "A",
+            startRow: "5",
+            endRow: "1",
+        })).toThrow(InvalidArgumentError);
+    });
+});
+describe("isAddressOverlapping", () => {
+    it("should return true for overlapping cell ranges", () => {
+        expect(isAddressOverlapping("A1:C3", "B2:D4")).toBe(true);
+        expect(isAddressOverlapping("A1:B2", "A1:B2")).toBe(true); // Exact overlap
+        expect(isAddressOverlapping("A1:D4", "B2:C3")).toBe(true); // Nested overlap
+    });
+    it("should return false for non-overlapping cell ranges", () => {
+        expect(isAddressOverlapping("A1:B2", "C3:D4")).toBe(false);
+        expect(isAddressOverlapping("A1:A1", "B1:B1")).toBe(false);
+        expect(isAddressOverlapping("A1:A10", "B11:B20")).toBe(false);
+    });
+    it("should return true for overlapping row ranges", () => {
+        expect(isAddressOverlapping("1:5", "3:7")).toBe(true);
+        expect(isAddressOverlapping("1:10", "5:15")).toBe(true);
+    });
+    it("should return false for non-overlapping row ranges", () => {
+        expect(isAddressOverlapping("1:5", "6:10")).toBe(false);
+        expect(isAddressOverlapping("1:1", "2:2")).toBe(false);
+    });
+    it("should return true for overlapping column ranges", () => {
+        expect(isAddressOverlapping("A:C", "B:D")).toBe(true);
+        expect(isAddressOverlapping("A:Z", "M:N")).toBe(true);
+    });
+    it("should return false for non-overlapping column ranges", () => {
+        expect(isAddressOverlapping("A:C", "D:F")).toBe(false);
+        expect(isAddressOverlapping("A:A", "B:B")).toBe(false);
+    });
+    it("should handle single cell addresses", () => {
+        expect(isAddressOverlapping("A1", "A1")).toBe(true); // Exact match
+        expect(isAddressOverlapping("A1", "B2")).toBe(false); // No overlap
+        expect(isAddressOverlapping("A1", "A2")).toBe(false); // Different rows
+        expect(isAddressOverlapping("A1", "B1")).toBe(false); // Different columns
+    });
+});

package/dist/services/addressOffset.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnAddress, RowAddress } from "../models/Address.ts";
+import type { ColumnOffset } from "../models/ColumnOffset.ts";
+import type { RowOffset } from "../models/RowOffset.ts";
+export declare function columnAddressToOffset(column: ColumnAddress): ColumnOffset;
+export declare function offsetToColumnAddress(offset: ColumnOffset): ColumnAddress;
+export declare function rowAddressToOffset(row: RowAddress): RowOffset;
+export declare function offsetToRowAddress(offset: RowOffset): RowAddress;
+//# sourceMappingURL=addressOffset.d.ts.map

package/dist/services/addressOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressOffset.d.ts","sourceRoot":"","sources":["../../src/services/addressOffset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,CAMzE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,CASzE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,CAE7D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAEhE"}

package/dist/services/addressOffset.js

@@ -0,0 +1,23 @@
+export function columnAddressToOffset(column) {
+    let offset = 0;
+    for (let i = 0; i < column.length; i++) {
+        offset = offset * 26 + (column.charCodeAt(i) - 65 + 1);
+    }
+    return (offset - 1);
+}
+export function offsetToColumnAddress(offset) {
+    let result = "";
+    let currentOffset = offset + 1;
+    while (currentOffset > 0) {
+        currentOffset -= 1;
+        result = String.fromCharCode((currentOffset % 26) + 65) + result;
+        currentOffset = Math.floor(currentOffset / 26);
+    }
+    return result;
+}
+export function rowAddressToOffset(row) {
+    return (Number.parseInt(row, 10) - 1);
+}
+export function offsetToRowAddress(offset) {
+    return (offset + 1).toString();
+}

package/dist/services/addressOffset.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=addressOffset.test.d.ts.map

package/dist/services/addressOffset.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressOffset.test.d.ts","sourceRoot":"","sources":["../../src/services/addressOffset.test.ts"],"names":[],"mappings":""}

package/dist/services/addressOffset.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { columnAddressToOffset, offsetToColumnAddress, offsetToRowAddress, rowAddressToOffset } from "./addressOffset.js";
+describe("columnAddressToOffset", () => {
+    it("should convert column address to offset", () => {
+        expect(columnAddressToOffset("A")).toBe(0);
+        expect(columnAddressToOffset("B")).toBe(1);
+        expect(columnAddressToOffset("Z")).toBe(25);
+        expect(columnAddressToOffset("AA")).toBe(26);
+        expect(columnAddressToOffset("AB")).toBe(27);
+        expect(columnAddressToOffset("AZ")).toBe(51);
+        expect(columnAddressToOffset("BA")).toBe(52);
+    });
+});
+describe("offsetToColumnAddress", () => {
+    it("should convert offset to column address", () => {
+        expect(offsetToColumnAddress(0)).toBe("A");
+        expect(offsetToColumnAddress(1)).toBe("B");
+        expect(offsetToColumnAddress(25)).toBe("Z");
+        expect(offsetToColumnAddress(26)).toBe("AA");
+        expect(offsetToColumnAddress(27)).toBe("AB");
+        expect(offsetToColumnAddress(51)).toBe("AZ");
+        expect(offsetToColumnAddress(52)).toBe("BA");
+    });
+});
+describe("rowAddressToOffset", () => {
+    it("should convert row address to offset", () => {
+        expect(rowAddressToOffset("1")).toBe(0);
+        expect(rowAddressToOffset("2")).toBe(1);
+        expect(rowAddressToOffset("10")).toBe(9);
+    });
+});
+describe("offsetToRowAddress", () => {
+    it("should convert offset to row address", () => {
+        expect(offsetToRowAddress(0)).toBe("1");
+        expect(offsetToRowAddress(1)).toBe("2");
+        expect(offsetToRowAddress(9)).toBe("10");
+    });
+});

package/dist/tasks/deleteDriveItemWithRetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteDriveItemWithRetry.d.ts","sourceRoot":"","sources":["../../src/tasks/deleteDriveItemWithRetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAI9D,8EAA8E;AAC9E,wBAA8B,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAchG"}
+{"version":3,"file":"deleteDriveItemWithRetry.d.ts","sourceRoot":"","sources":["../../src/tasks/deleteDriveItemWithRetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAI9D,8EAA8E;AAC9E,wBAA8B,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAahG"}

package/dist/tasks/deleteDriveItemWithRetry.js

@@ -12,6 +12,5 @@ export default async function deleteDriveItemWithRetry(driveItemRef) {
             await sleep(delay);
         }
     }
-    // Final attempt without delay
     await deleteDriveItem(driveItemRef);
 }

package/dist/tasks/getRangeLastUsedCell.d.ts

@@ -3,7 +3,5 @@ import type { WorkbookRangeRef } from "../models/WorkbookRangeRef.ts";
 export default function getRangeLastUsedCell(rangeRef: WorkbookRangeRef): Promise<{
     value: string | number | boolean | null;
     address: string;
-    rowIndex: number;
-    columnIndex: number;
 } | null>;
 //# sourceMappingURL=getRangeLastUsedCell.d.ts.map

package/dist/tasks/getRangeLastUsedCell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRangeLastUsedCell.d.ts","sourceRoot":"","sources":["../../src/tasks/getRangeLastUsedCell.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAItE,0EAA0E;AAC1E,wBAA8B,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAyClM"}
+{"version":3,"file":"getRangeLastUsedCell.d.ts","sourceRoot":"","sources":["../../src/tasks/getRangeLastUsedCell.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAItE,0EAA0E;AAC1E,wBAA8B,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAyC3J"}

package/dist/tasks/getRangeLastUsedCell.js

@@ -1,6 +1,6 @@
 import ProtocolError from "../errors/ProtocolError.js";
 import getWorkbookWorksheetRange from "../operations/workbookRange/getWorkbookWorksheetRange.js";
-import { indexesToCellAddress } from "../services/address.js";
+import { getFirstCellAddress, offsetAddress } from "../services/addressManipulation.js";
 /** Get the last used cell (ie, the most-lower-right) in a given range. */
 export default async function getRangeLastUsedCell(rangeRef) {
     // TODO: Consider adding chunking if the range is too large
@@ -25,12 +25,11 @@ export default async function getRangeLastUsedCell(rangeRef) {
                 throw new ProtocolError("Cell missing");
             }
             if (cell !== null && cell !== "") {
-                const address = indexesToCellAddress(rowIndex, columnIndex);
+                const firstCellAddress = getFirstCellAddress(rangeRef.address);
+                const lastUsedCellAddress = offsetAddress(firstCellAddress, columnIndex, rowIndex);
                 return {
                     value: cell,
-                    address,
-                    rowIndex: rowIndex,
-                    columnIndex: columnIndex,
+                    address: lastUsedCellAddress,
                 };
             }
         }

package/dist/tasks/getRangeLastUsedCell.test.js

@@ -31,8 +31,6 @@ describe("getRangeLastUsedCell", () => {
             }
             expect(result.value).toBe(4);
             expect(result.address).toBe("B2");
-            expect(result.rowIndex).toBe(1);
-            expect(result.columnIndex).toBe(1);
         }
         finally {
             await deleteDriveItemWithRetry(workbook);
@@ -58,8 +56,6 @@ describe("getRangeLastUsedCell", () => {
             }
             expect(result.value).toBe(3);
             expect(result.address).toBe("A2");
-            expect(result.rowIndex).toBe(1);
-            expect(result.columnIndex).toBe(0);
         }
         finally {
             await deleteDriveItemWithRetry(workbook);

package/dist/tasks/setWorkbookTableBodyVisibleRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setWorkbookTableBodyVisibleRows.d.ts","sourceRoot":"","sources":["../../src/tasks/setWorkbookTableBodyVisibleRows.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAQtE,oLAAoL;AACpL,wBAAsB,+BAA+B,CAAC,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCnH"}
+{"version":3,"file":"setWorkbookTableBodyVisibleRows.d.ts","sourceRoot":"","sources":["../../src/tasks/setWorkbookTableBodyVisibleRows.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAQtE,oLAAoL;AACpL,wBAAsB,+BAA+B,CAAC,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BnH"}

package/dist/tasks/setWorkbookTableBodyVisibleRows.js

@@ -1,10 +1,9 @@
 import InvalidArgumentError from "../errors/InvalidArgumentError.js";
-import NeverError from "../errors/NeverError.js";
 import getWorkbookWorksheetRange from "../operations/workbookRange/getWorkbookWorksheetRange.js";
 import insertWorkbookCells from "../operations/workbookRange/insertWorkbookCells.js";
 import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
 import getWorkbookTableBodyRange from "../operations/workbookTable/getWorkbookTableBodyRange.js";
-import { cellAddressToIndexes, getAddressFirstCell, getAddressLastCell, indexesToBoxRangeAddress } from "../services/address.js";
+import { getFirstRowAddress, incrementRowAddress, isAddressOverlapping } from "../services/addressManipulation.js";
 import { createWorkbookRangeRef } from "../services/workbookRange.js";
 /** Overwrite visible rows of a workbook table with the provided 2D array of values, inserting new rows at the end if needed. THIS IS SLOW as it must check each rows visibility. */
 export async function setWorkbookTableBodyVisibleRows(tableRef, values) {
@@ -12,27 +11,23 @@ export async function setWorkbookTableBodyVisibleRows(tableRef, values) {
     if (values.some((row) => row.length !== visibleRange.columnCount)) {
         throw new InvalidArgumentError(`Invalid number of columns in input values. Expected all rows to have ${visibleRange.columnCount}.`);
     }
-    const [startRowIndex, startColumnIndex] = cellAddressToIndexes(getAddressFirstCell(visibleRange.address));
-    const [endRowIndex, endColumnIndex] = cellAddressToIndexes(getAddressLastCell(visibleRange.address));
-    if (endColumnIndex - startColumnIndex + 1 !== visibleRange.columnCount) {
-        throw new NeverError("Insane address");
-    }
-    let currentRowIndex = startRowIndex;
+    const dstFirstRowAddress = getFirstRowAddress(visibleRange.address);
+    let dstCurrentRowAddress = dstFirstRowAddress;
     for (const srcRowValues of values) {
         let dstRowRef;
         let dstRow;
         let dstRowHidden = false;
         do {
-            dstRowRef = createWorkbookRangeRef(tableRef, indexesToBoxRangeAddress(currentRowIndex, startColumnIndex, currentRowIndex, endColumnIndex));
-            if (currentRowIndex > endRowIndex) {
-                await insertWorkbookCells(dstRowRef, dstRowRef.address, "Down");
-                dstRowHidden = false;
-            }
-            else {
+            dstRowRef = createWorkbookRangeRef(tableRef, dstCurrentRowAddress);
+            if (isAddressOverlapping(dstCurrentRowAddress, visibleRange.address)) {
                 dstRow = await getWorkbookWorksheetRange(dstRowRef);
                 dstRowHidden = dstRow.rowHidden ?? false;
             }
-            currentRowIndex++;
+            else {
+                await insertWorkbookCells(dstRowRef, dstRowRef.address, "Down");
+                dstRowHidden = false;
+            }
+            dstCurrentRowAddress = incrementRowAddress(dstCurrentRowAddress);
         } while (dstRowHidden);
         await updateWorkbookRange(dstRowRef, { values: [srcRowValues] });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "microsoft-graph",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "Microsoft GraphAPI SDK for NodeJS",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -85,6 +85,10 @@
       "import": "./dist/errors/RequestFailedError.js",
       "types": "./dist/errors/RequestFailedError.d.ts"
     },
+    "./errors/UnsupportedAddressTypeError": {
+      "import": "./dist/errors/UnsupportedAddressTypeError.js",
+      "types": "./dist/errors/UnsupportedAddressTypeError.d.ts"
+    },
     "./graphApi": {
       "import": "./dist/graphApi.js",
       "types": "./dist/graphApi.d.ts"
@@ -121,6 +125,10 @@
       "import": "./dist/models/ColumnIndex.js",
       "types": "./dist/models/ColumnIndex.d.ts"
     },
+    "./models/ColumnOffset": {
+      "import": "./dist/models/ColumnOffset.js",
+      "types": "./dist/models/ColumnOffset.d.ts"
+    },
     "./models/Context": {
       "import": "./dist/models/Context.js",
       "types": "./dist/models/Context.d.ts"
@@ -181,6 +189,10 @@
       "import": "./dist/models/RowIndex.js",
       "types": "./dist/models/RowIndex.d.ts"
     },
+    "./models/RowOffset": {
+      "import": "./dist/models/RowOffset.js",
+      "types": "./dist/models/RowOffset.d.ts"
+    },
     "./models/Scope": {
       "import": "./dist/models/Scope.js",
       "types": "./dist/models/Scope.d.ts"
@@ -413,6 +425,14 @@
       "import": "./dist/services/address.js",
       "types": "./dist/services/address.d.ts"
     },
+    "./services/addressManipulation": {
+      "import": "./dist/services/addressManipulation.js",
+      "types": "./dist/services/addressManipulation.d.ts"
+    },
+    "./services/addressOffset": {
+      "import": "./dist/services/addressOffset.js",
+      "types": "./dist/services/addressOffset.d.ts"
+    },
     "./services/context": {
       "import": "./dist/services/context.js",
       "types": "./dist/services/context.d.ts"