@pnp/cli-microsoft365 10.0.0-beta.a868b81 → 10.0.0-beta.b184dfb

package/dist/m365/spo/commands/folder/folder-move.js

@@ -5,6 +5,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _SpoFolderMoveCommand_instances, _SpoFolderMoveCommand_initTelemetry, _SpoFolderMoveCommand_initOptions, _SpoFolderMoveCommand_initValidators, _SpoFolderMoveCommand_initOptionSets, _SpoFolderMoveCommand_initTypes;
 import request from '../../../../request.js';
+import { CreateFolderCopyJobsNameConflictBehavior, spo } from '../../../../utils/spo.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
@@ -31,45 +32,54 @@ class SpoFolderMoveCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         try {
-            const sourcePath = await this.getSourcePath(logger, args.options);
+            const sourceServerRelativePath = await this.getSourcePath(logger, args.options);
+            const sourcePath = this.getAbsoluteUrl(args.options.webUrl, sourceServerRelativePath);
+            const destinationPath = this.getAbsoluteUrl(args.options.webUrl, args.options.targetUrl);
             if (this.verbose) {
-                await logger.logToStderr(`Moving folder '${sourcePath}' to '${args.options.targetUrl}'...`);
+                await logger.logToStderr(`Moving folder '${sourcePath}' to '${destinationPath}'...`);
             }
-            const absoluteSourcePath = this.getAbsoluteUrl(args.options.webUrl, sourcePath);
-            let absoluteTargetPath = this.getAbsoluteUrl(args.options.webUrl, args.options.targetUrl) + '/';
-            if (args.options.newName) {
-                absoluteTargetPath += args.options.newName;
+            const copyJobResponse = await spo.createFolderCopyJob(args.options.webUrl, sourcePath, destinationPath, {
+                nameConflictBehavior: this.getNameConflictBehaviorValue(args.options.nameConflictBehavior),
+                newName: args.options.newName,
+                operation: 'move'
+            });
+            if (args.options.skipWait) {
+                return;
             }
-            else {
-                // Keep the original file name
-                absoluteTargetPath += sourcePath.substring(sourcePath.lastIndexOf('/') + 1);
+            if (this.verbose) {
+                await logger.logToStderr('Waiting for the move job to complete...');
+            }
+            const copyJobResult = await spo.getCopyJobResult(args.options.webUrl, copyJobResponse);
+            if (this.verbose) {
+                await logger.logToStderr('Getting information about the destination folder...');
             }
+            // Get destination folder data
+            const siteRelativeDestinationFolder = '/' + copyJobResult.TargetObjectSiteRelativeUrl.substring(0, copyJobResult.TargetObjectSiteRelativeUrl.lastIndexOf('/'));
+            const absoluteWebUrl = destinationPath.substring(0, destinationPath.toLowerCase().lastIndexOf(siteRelativeDestinationFolder.toLowerCase()));
             const requestOptions = {
-                url: `${args.options.webUrl}/_api/SP.MoveCopyUtil.MoveFolderByPath`,
+                url: `${absoluteWebUrl}/_api/Web/GetFolderById('${copyJobResult.TargetObjectUniqueId}')`,
                 headers: {
                     accept: 'application/json;odata=nometadata'
                 },
-                responseType: 'json',
-                data: {
-                    srcPath: {
-                        DecodedUrl: absoluteSourcePath
-                    },
-                    destPath: {
-                        DecodedUrl: absoluteTargetPath
-                    },
-                    options: {
-                        KeepBoth: args.options.nameConflictBehavior === 'rename',
-                        ShouldBypassSharedLocks: !!args.options.bypassSharedLock,
-                        RetainEditorAndModifiedOnMove: !!args.options.retainEditorAndModified
-                    }
-                }
+                responseType: 'json'
             };
-            await request.post(requestOptions);
+            const destinationFile = await request.get(requestOptions);
+            await logger.log(destinationFile);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
+    getNameConflictBehaviorValue(nameConflictBehavior) {
+        switch (nameConflictBehavior?.toLowerCase()) {
+            case 'fail':
+                return CreateFolderCopyJobsNameConflictBehavior.Fail;
+            case 'rename':
+                return CreateFolderCopyJobsNameConflictBehavior.Rename;
+            default:
+                return CreateFolderCopyJobsNameConflictBehavior.Fail;
+        }
+    }
     async getSourcePath(logger, options) {
         if (options.sourceUrl) {
             return urlUtil.getServerRelativePath(options.webUrl, options.sourceUrl);
@@ -78,17 +88,18 @@ class SpoFolderMoveCommand extends SpoCommand {
             await logger.logToStderr(`Retrieving server-relative path for folder with ID '${options.sourceId}'...`);
         }
         const requestOptions = {
-            url: `${options.webUrl}/_api/Web/GetFolderById('${options.sourceId}')?$select=ServerRelativePath`,
+            url: `${options.webUrl}/_api/Web/GetFolderById('${options.sourceId}')/ServerRelativePath`,
             headers: {
                 accept: 'application/json;odata=nometadata'
             },
             responseType: 'json'
         };
-        const file = await request.get(requestOptions);
-        return file.ServerRelativePath.DecodedUrl;
+        const path = await request.get(requestOptions);
+        return path.DecodedUrl;
     }
     getAbsoluteUrl(webUrl, url) {
-        return url.startsWith('https://') ? url : urlUtil.getAbsoluteUrl(webUrl, url);
+        const result = url.startsWith('https://') ? url : urlUtil.getAbsoluteUrl(webUrl, url);
+        return urlUtil.removeTrailingSlashes(result);
     }
 }
 _SpoFolderMoveCommand_instances = new WeakSet(), _SpoFolderMoveCommand_initTelemetry = function _SpoFolderMoveCommand_initTelemetry() {
@@ -98,8 +109,7 @@ _SpoFolderMoveCommand_instances = new WeakSet(), _SpoFolderMoveCommand_initTelem
             sourceId: typeof args.options.sourceId !== 'undefined',
             newName: typeof args.options.newName !== 'undefined',
             nameConflictBehavior: typeof args.options.nameConflictBehavior !== 'undefined',
-            retainEditorAndModified: !!args.options.retainEditorAndModified,
-            bypassSharedLock: !!args.options.bypassSharedLock
+            skipWait: !!args.options.skipWait
         });
     });
 }, _SpoFolderMoveCommand_initOptions = function _SpoFolderMoveCommand_initOptions() {
@@ -117,9 +127,7 @@ _SpoFolderMoveCommand_instances = new WeakSet(), _SpoFolderMoveCommand_initTelem
         option: '--nameConflictBehavior [nameConflictBehavior]',
         autocomplete: this.nameConflictBehaviorOptions
     }, {
-        option: '--retainEditorAndModified'
-    }, {
-        option: '--bypassSharedLock'
+        option: '--skipWait'
     });
 }, _SpoFolderMoveCommand_initValidators = function _SpoFolderMoveCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -139,7 +147,7 @@ _SpoFolderMoveCommand_instances = new WeakSet(), _SpoFolderMoveCommand_initTelem
     this.optionSets.push({ options: ['sourceUrl', 'sourceId'] });
 }, _SpoFolderMoveCommand_initTypes = function _SpoFolderMoveCommand_initTypes() {
     this.types.string.push('webUrl', 'sourceUrl', 'sourceId', 'targetUrl', 'newName', 'nameConflictBehavior');
-    this.types.boolean.push('retainEditorAndModified', 'bypassSharedLock');
+    this.types.boolean.push('skipWait');
 };
 export default new SpoFolderMoveCommand();
 //# sourceMappingURL=folder-move.js.map

package/dist/m365/spo/commands/folder/folder-sharinglink-add.js

@@ -0,0 +1,143 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpoFolderSharingLinkAddCommand_instances, _SpoFolderSharingLinkAddCommand_initTelemetry, _SpoFolderSharingLinkAddCommand_initOptions, _SpoFolderSharingLinkAddCommand_initValidators, _SpoFolderSharingLinkAddCommand_initOptionSets, _SpoFolderSharingLinkAddCommand_initTypes;
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import { formatting } from '../../../../utils/formatting.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkAddCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_ADD;
+    }
+    get description() {
+        return 'Creates a new sharing link to a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkAddCommand_instances.add(this);
+        this.allowedTypes = ['view', 'edit'];
+        this.allowedScopes = ['anonymous', 'organization', 'users'];
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkAddCommand_instances, "m", _SpoFolderSharingLinkAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkAddCommand_instances, "m", _SpoFolderSharingLinkAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkAddCommand_instances, "m", _SpoFolderSharingLinkAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkAddCommand_instances, "m", _SpoFolderSharingLinkAddCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkAddCommand_instances, "m", _SpoFolderSharingLinkAddCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            await logger.logToStderr(`Creating a sharing link to a folder ${args.options.folderId || args.options.folderUrl}...`);
+        }
+        try {
+            const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+            const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+            const folderUrl = new URL(absoluteFolderUrl);
+            const siteId = await spo.getSiteId(args.options.webUrl);
+            const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+            const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+            const requestOptions = {
+                url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/createLink`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: {
+                    type: args.options.type,
+                    expirationDateTime: args.options.expirationDateTime,
+                    scope: args.options.scope,
+                    retainInheritedPermissions: !!args.options.retainInheritiedPermissions
+                }
+            };
+            if (args.options.scope === 'users' && args.options.recipients) {
+                const recipients = formatting.splitAndTrim(args.options.recipients).map(email => ({ email }));
+                requestOptions.data.recipients = recipients;
+            }
+            const sharingLink = await request.post(requestOptions);
+            // remove grantedToIdentities from the sharing link object
+            if (sharingLink.grantedToIdentities) {
+                delete sharingLink.grantedToIdentities;
+            }
+            await logger.log(sharingLink);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_SpoFolderSharingLinkAddCommand_instances = new WeakSet(), _SpoFolderSharingLinkAddCommand_initTelemetry = function _SpoFolderSharingLinkAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            folderId: typeof args.options.folderId !== 'undefined',
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            type: typeof args.options.type !== 'undefined',
+            expirationDateTime: typeof args.options.expirationDateTime !== 'undefined',
+            scope: typeof args.options.scope !== 'undefined',
+            retainInheritiedPermissions: !!args.options.retainInheritiedPermissions,
+            recipients: typeof args.options.recipients !== 'undefined'
+        });
+    });
+}, _SpoFolderSharingLinkAddCommand_initOptions = function _SpoFolderSharingLinkAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
+        option: '--folderId [folderId]'
+    }, {
+        option: '--folderUrl [folderUrl]'
+    }, {
+        option: '--type <type>',
+        autocomplete: this.allowedTypes
+    }, {
+        option: '--expirationDateTime [expirationDateTime]'
+    }, {
+        option: '--scope [scope]',
+        autocomplete: this.allowedScopes
+    }, {
+        option: '--retainInheritedPermissions [retainInheritedPermissions]'
+    }, {
+        option: '--recipients [recipients]'
+    });
+}, _SpoFolderSharingLinkAddCommand_initValidators = function _SpoFolderSharingLinkAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        if (args.options.type && !this.allowedTypes.some(type => type === args.options.type)) {
+            return `'${args.options.type}' is not a valid type. Allowed values are: ${this.allowedTypes.join(',')}`;
+        }
+        if (args.options.scope) {
+            if (!this.allowedScopes.includes(args.options.scope)) {
+                return `'${args.options.scope}' is not a valid scope. Allowed values are: ${this.allowedScopes.join(', ')}.`;
+            }
+        }
+        if (args.options.expirationDateTime && !validation.isValidISODateTime(args.options.expirationDateTime)) {
+            return `${args.options.expirationDateTime} is not a valid ISO date string.`;
+        }
+        if (args.options.recipients) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.recipients);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for the option 'recipients': ${isValidUPNArrayResult}.`;
+            }
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkAddCommand_initOptionSets = function _SpoFolderSharingLinkAddCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderId', 'folderUrl'] }, {
+        options: ['recipients'],
+        runsWhen: (args) => args.options.scope !== undefined && args.options.scope === 'users'
+    });
+}, _SpoFolderSharingLinkAddCommand_initTypes = function _SpoFolderSharingLinkAddCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderId', 'folderUrl', 'type', 'expirationDateTime', 'scope', 'recipients');
+    this.types.boolean.push('retainInheritiedPermissions');
+};
+export default new SpoFolderSharingLinkAddCommand();
+//# sourceMappingURL=folder-sharinglink-add.js.map

package/dist/m365/spo/commands/folder/folder-sharinglink-clear.js

@@ -0,0 +1,111 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpoFolderSharingLinkClearCommand_instances, _SpoFolderSharingLinkClearCommand_initTelemetry, _SpoFolderSharingLinkClearCommand_initOptions, _SpoFolderSharingLinkClearCommand_initOptionSets, _SpoFolderSharingLinkClearCommand_initValidators, _SpoFolderSharingLinkClearCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import { spo } from '../../../../utils/spo.js';
+import { odata } from '../../../../utils/odata.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import request from '../../../../request.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkClearCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_CLEAR;
+    }
+    get description() {
+        return 'Removes all sharing links of a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkClearCommand_instances.add(this);
+        this.allowedScopes = ['anonymous', 'users', 'organization'];
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const clearSharingLinks = async () => {
+            if (this.verbose) {
+                await logger.logToStderr(`Clearing sharing links from folder ${args.options.folderId || args.options.folderUrl} for ${args.options.scope ? `${args.options.scope} scope` : 'all scopes'}`);
+            }
+            try {
+                const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+                const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+                const folderUrl = new URL(absoluteFolderUrl);
+                const siteId = await spo.getSiteId(args.options.webUrl);
+                const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+                const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+                let requestUrl = `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions?$filter=Link ne null`;
+                if (args.options.scope) {
+                    requestUrl += ` and Link/Scope eq '${args.options.scope}'`;
+                }
+                const sharingLinks = await odata.getAllItems(requestUrl);
+                for (const sharingLink of sharingLinks) {
+                    const requestOptions = {
+                        url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions/${sharingLink.id}`,
+                        headers: {
+                            accept: 'application/json;odata.metadata=none'
+                        }
+                    };
+                    await request.delete(requestOptions);
+                }
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await clearSharingLinks();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to clear sharing links from folder ${args.options.folderUrl || args.options.folderId}? for ${args.options.scope ? `${args.options.scope} scope` : 'all scopes'}` });
+            if (result) {
+                await clearSharingLinks();
+            }
+        }
+    }
+}
+_SpoFolderSharingLinkClearCommand_instances = new WeakSet(), _SpoFolderSharingLinkClearCommand_initTelemetry = function _SpoFolderSharingLinkClearCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            webUrl: typeof args.options.webUrl !== 'undefined',
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined',
+            scope: typeof args.options.scope !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _SpoFolderSharingLinkClearCommand_initOptions = function _SpoFolderSharingLinkClearCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, {
+        option: '--scope [scope]',
+        autocomplete: this.allowedScopes
+    }, { option: '-f, --force' });
+}, _SpoFolderSharingLinkClearCommand_initOptionSets = function _SpoFolderSharingLinkClearCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderUrl', 'folderId'] });
+}, _SpoFolderSharingLinkClearCommand_initValidators = function _SpoFolderSharingLinkClearCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        if (args.options.scope && !this.allowedScopes.some(scope => scope === args.options.scope)) {
+            return `'${args.options.scope}' is not a valid scope. Allowed values are: ${this.allowedScopes.join(',')}`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkClearCommand_initTypes = function _SpoFolderSharingLinkClearCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderUrl', 'folderId', 'scope');
+    this.types.boolean.push('force');
+};
+export default new SpoFolderSharingLinkClearCommand();
+//# sourceMappingURL=folder-sharinglink-clear.js.map

package/dist/m365/spo/commands/folder/folder-sharinglink-remove.js

@@ -0,0 +1,95 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpoFolderSharingLinkRemoveCommand_instances, _SpoFolderSharingLinkRemoveCommand_initTelemetry, _SpoFolderSharingLinkRemoveCommand_initOptions, _SpoFolderSharingLinkRemoveCommand_initOptionSets, _SpoFolderSharingLinkRemoveCommand_initValidators, _SpoFolderSharingLinkRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import request from '../../../../request.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_REMOVE;
+    }
+    get description() {
+        return 'Removes a sharing link from a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeSharingLink = async () => {
+            if (this.verbose) {
+                await logger.logToStderr(`Removing sharing link of folder ${args.options.folderId || args.options.folderUrl} with id ${args.options.id}...`);
+            }
+            try {
+                const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+                const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+                const folderUrl = new URL(absoluteFolderUrl);
+                const siteId = await spo.getSiteId(args.options.webUrl);
+                const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+                const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+                const requestOptions = {
+                    url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions/${args.options.id}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                return request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeSharingLink();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove sharing link ${args.options.id} of folder ${args.options.folderUrl || args.options.folderId}?` });
+            if (result) {
+                await removeSharingLink();
+            }
+        }
+    }
+}
+_SpoFolderSharingLinkRemoveCommand_instances = new WeakSet(), _SpoFolderSharingLinkRemoveCommand_initTelemetry = function _SpoFolderSharingLinkRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _SpoFolderSharingLinkRemoveCommand_initOptions = function _SpoFolderSharingLinkRemoveCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, { option: '-i, --id <id>' }, { option: '-f, --force' });
+}, _SpoFolderSharingLinkRemoveCommand_initOptionSets = function _SpoFolderSharingLinkRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderUrl', 'folderId'] });
+}, _SpoFolderSharingLinkRemoveCommand_initValidators = function _SpoFolderSharingLinkRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkRemoveCommand_initTypes = function _SpoFolderSharingLinkRemoveCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderUrl', 'folderId', 'id');
+    this.types.boolean.push('force');
+};
+export default new SpoFolderSharingLinkRemoveCommand();
+//# sourceMappingURL=folder-sharinglink-remove.js.map

package/dist/m365/spo/commands/folder/folder-sharinglink-set.js

@@ -0,0 +1,90 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpoFolderSharingLinkSetCommand_instances, _SpoFolderSharingLinkSetCommand_initTelemetry, _SpoFolderSharingLinkSetCommand_initOptions, _SpoFolderSharingLinkSetCommand_initValidators, _SpoFolderSharingLinkSetCommand_initOptionSets, _SpoFolderSharingLinkSetCommand_initTypes;
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkSetCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_SET;
+    }
+    get description() {
+        return 'Updates a specific sharing link to a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkSetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkSetCommand_instances, "m", _SpoFolderSharingLinkSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkSetCommand_instances, "m", _SpoFolderSharingLinkSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkSetCommand_instances, "m", _SpoFolderSharingLinkSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkSetCommand_instances, "m", _SpoFolderSharingLinkSetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkSetCommand_instances, "m", _SpoFolderSharingLinkSetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            await logger.logToStderr(`Updating sharing link to a folder ${args.options.folderId || args.options.folderUrl}...`);
+        }
+        try {
+            const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+            const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+            const folderUrl = new URL(absoluteFolderUrl);
+            const siteId = await spo.getSiteId(args.options.webUrl);
+            const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+            const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+            const requestOptions = {
+                url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions/${args.options.id}`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    'content-type': 'application/json'
+                },
+                responseType: 'json',
+                data: {
+                    expirationDateTime: args.options.expirationDateTime
+                }
+            };
+            const sharingLink = await request.patch(requestOptions);
+            await logger.log(sharingLink);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_SpoFolderSharingLinkSetCommand_instances = new WeakSet(), _SpoFolderSharingLinkSetCommand_initTelemetry = function _SpoFolderSharingLinkSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined',
+            expirationDateTime: typeof args.options.expirationDateTime !== 'undefined'
+        });
+    });
+}, _SpoFolderSharingLinkSetCommand_initOptions = function _SpoFolderSharingLinkSetCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, { option: '-i, --id <id>' }, { option: '--expirationDateTime [expirationDateTime]' });
+}, _SpoFolderSharingLinkSetCommand_initValidators = function _SpoFolderSharingLinkSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        if (args.options.expirationDateTime && !validation.isValidISODateTime(args.options.expirationDateTime)) {
+            return `${args.options.expirationDateTime} is not a valid ISO date string.`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkSetCommand_initOptionSets = function _SpoFolderSharingLinkSetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderId', 'folderUrl'] });
+}, _SpoFolderSharingLinkSetCommand_initTypes = function _SpoFolderSharingLinkSetCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderId', 'folderUrl', 'id', 'expirationDateTime');
+};
+export default new SpoFolderSharingLinkSetCommand();
+//# sourceMappingURL=folder-sharinglink-set.js.map

package/dist/m365/spo/commands/group/group-member-add.js

@@ -31,14 +31,6 @@ class SpoGroupMemberAddCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         try {
-            if (args.options.aadGroupIds) {
-                args.options.entraGroupIds = args.options.aadGroupIds;
-                await this.warn(logger, `Option 'aadGroupIds' is deprecated. Please use 'entraGroupIds' instead.`);
-            }
-            if (args.options.aadGroupNames) {
-                args.options.entraGroupNames = args.options.aadGroupNames;
-                await this.warn(logger, `Option 'aadGroupNames' is deprecated. Please use 'entraGroupNames' instead.`);
-            }
             const loginNames = await this.getLoginNames(logger, args.options);
             let apiUrl = `${args.options.webUrl}/_api/web/SiteGroups`;
             if (args.options.groupId) {
@@ -132,9 +124,7 @@ _SpoGroupMemberAddCommand_instances = new WeakSet(), _SpoGroupMemberAddCommand_i
             emails: typeof args.options.emails !== 'undefined',
             userIds: typeof args.options.userIds !== 'undefined',
             entraGroupIds: typeof args.options.entraGroupIds !== 'undefined',
-            aadGroupIds: typeof args.options.aadGroupIds !== 'undefined',
-            entraGroupNames: typeof args.options.entraGroupNames !== 'undefined',
-            aadGroupNames: typeof args.options.aadGroupNames !== 'undefined'
+            entraGroupNames: typeof args.options.entraGroupNames !== 'undefined'
         });
     });
 }, _SpoGroupMemberAddCommand_initOptions = function _SpoGroupMemberAddCommand_initOptions() {
@@ -152,12 +142,8 @@ _SpoGroupMemberAddCommand_instances = new WeakSet(), _SpoGroupMemberAddCommand_i
         option: '--userIds [userIds]'
     }, {
         option: '--entraGroupIds [entraGroupIds]'
-    }, {
-        option: '--aadGroupIds [aadGroupIds]'
     }, {
         option: '--entraGroupNames [entraGroupNames]'
-    }, {
-        option: '--aadGroupNames [aadGroupNames]'
     });
 }, _SpoGroupMemberAddCommand_initValidators = function _SpoGroupMemberAddCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -192,18 +178,12 @@ _SpoGroupMemberAddCommand_instances = new WeakSet(), _SpoGroupMemberAddCommand_i
                 return `Option 'entraGroupIds' contains one or more invalid GUIDs: ${isValidArray}.`;
             }
         }
-        if (args.options.aadGroupIds) {
-            const isValidArray = validation.isValidGuidArray(args.options.aadGroupIds);
-            if (isValidArray !== true) {
-                return `Option 'aadGroupIds' contains one or more invalid GUIDs: ${isValidArray}.`;
-            }
-        }
         return true;
     });
 }, _SpoGroupMemberAddCommand_initOptionSets = function _SpoGroupMemberAddCommand_initOptionSets() {
-    this.optionSets.push({ options: ['groupId', 'groupName'] }, { options: ['userNames', 'emails', 'userIds', 'entraGroupIds', 'aadGroupIds', 'entraGroupNames', 'aadGroupNames'] });
+    this.optionSets.push({ options: ['groupId', 'groupName'] }, { options: ['userNames', 'emails', 'userIds', 'entraGroupIds', 'entraGroupNames'] });
 }, _SpoGroupMemberAddCommand_initTypes = function _SpoGroupMemberAddCommand_initTypes() {
-    this.types.string.push('webUrl', 'groupName', 'userNames', 'emails', 'userIds', 'entraGroupIds', 'aadGroupIds', 'entraGroupNames', 'aadGroupNames');
+    this.types.string.push('webUrl', 'groupName', 'userNames', 'emails', 'userIds', 'entraGroupIds', 'entraGroupNames');
 };
 export default new SpoGroupMemberAddCommand();
 //# sourceMappingURL=group-member-add.js.map