@pnp/cli-microsoft365 7.6.0-beta.443bfd8 → 7.6.0-beta.480812d

package/dist/m365/outlook/commands/message/message-remove.js

@@ -0,0 +1,113 @@
+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 _OutlookMessageRemoveCommand_instances, _OutlookMessageRemoveCommand_initTelemetry, _OutlookMessageRemoveCommand_initOptions, _OutlookMessageRemoveCommand_initValidators, _OutlookMessageRemoveCommand_initTypes;
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { cli } from '../../../../cli/cli.js';
+import { validation } from '../../../../utils/validation.js';
+import { formatting } from '../../../../utils/formatting.js';
+class OutlookMessageRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.MESSAGE_REMOVE;
+    }
+    get description() {
+        return 'Permanently removes a specific message from a mailbox';
+    }
+    constructor() {
+        super();
+        _OutlookMessageRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+        let principalUrl = '';
+        if (isAppOnlyAccessToken) {
+            if (!args.options.userId && !args.options.userName) {
+                throw `The option 'userId' or 'userName' is required when removing a message using application permissions.`;
+            }
+            if (args.options.userId && args.options.userName) {
+                throw `Both options 'userId' and 'userName' cannot be used together when removing a message using application permissions.`;
+            }
+        }
+        else {
+            if (args.options.userId && args.options.userName) {
+                throw `Both options 'userId' and 'userName' cannot be used together when removing a message using delegated permissions.`;
+            }
+        }
+        if (args.options.userId || args.options.userName) {
+            principalUrl += `users/${args.options.userId || formatting.encodeQueryParameter(args.options.userName)}`;
+        }
+        else {
+            principalUrl += 'me';
+        }
+        const removeMessage = async () => {
+            try {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing message with id '${args.options.id}' using ${isAppOnlyAccessToken ? 'application' : 'delegated'} permissions.`);
+                }
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/${principalUrl}/messages/${args.options.id}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    }
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeMessage();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove message with id '${args.options.id}'?` });
+            if (result) {
+                await removeMessage();
+            }
+        }
+    }
+}
+_OutlookMessageRemoveCommand_instances = new WeakSet(), _OutlookMessageRemoveCommand_initTelemetry = function _OutlookMessageRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _OutlookMessageRemoveCommand_initOptions = function _OutlookMessageRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id <id>'
+    }, {
+        option: '--userId [userId]'
+    }, {
+        option: '--userName [userName]'
+    }, {
+        option: '-f, --force'
+    });
+}, _OutlookMessageRemoveCommand_initValidators = function _OutlookMessageRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `Value '${args.options.userId}' is not a valid GUID for option 'userId'.`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `Value '${args.options.userName}' is not a valid user principal name for option 'userName'.`;
+        }
+        return true;
+    });
+}, _OutlookMessageRemoveCommand_initTypes = function _OutlookMessageRemoveCommand_initTypes() {
+    this.types.string.push('id', 'userId', 'userName');
+    this.types.boolean.push('force');
+};
+export default new OutlookMessageRemoveCommand();
+//# sourceMappingURL=message-remove.js.map

package/dist/m365/outlook/commands.js

@@ -4,6 +4,7 @@ export default {
     MESSAGE_GET: `${prefix} message get`,
     MESSAGE_LIST: `${prefix} message list`,
     MESSAGE_MOVE: `${prefix} message move`,
+    MESSAGE_REMOVE: `${prefix} message remove`,
     REPORT_MAILACTIVITYCOUNTS: `${prefix} report mailactivitycounts`,
     REPORT_MAILACTIVITYUSERCOUNTS: `${prefix} report mailactivityusercounts`,
     REPORT_MAILACTIVITYUSERDETAIL: `${prefix} report mailactivityuserdetail`,

package/dist/m365/pp/commands/managementapp/managementapp-add.js

@@ -58,16 +58,16 @@ class PpManagementAppAddCommand extends PowerPlatformCommand {
             },
             responseType: 'json'
         };
-        const aadApps = await request.get((requestOptions));
-        if (aadApps.value.length === 0) {
+        const entraApps = await request.get((requestOptions));
+        if (entraApps.value.length === 0) {
             const applicationIdentifier = objectId ? `ID ${objectId}` : `name ${name}`;
-            throw `No Azure AD application registration with ${applicationIdentifier} found`;
+            throw `No Microsoft Entra application registration with ${applicationIdentifier} found`;
         }
-        if (aadApps.value.length === 1 && aadApps.value[0].appId) {
-            return aadApps.value[0].appId;
+        if (entraApps.value.length === 1 && entraApps.value[0].appId) {
+            return entraApps.value[0].appId;
         }
-        const resultAsKeyValuePair = formatting.convertArrayToHashTable('appId', aadApps.value);
-        const result = await cli.handleMultipleResultsFound(`Multiple Azure AD application registration with name '${name}' found.`, resultAsKeyValuePair);
+        const resultAsKeyValuePair = formatting.convertArrayToHashTable('appId', entraApps.value);
+        const result = await cli.handleMultipleResultsFound(`Multiple Microsoft Entra application registrations with name '${name}' found.`, resultAsKeyValuePair);
         return result.appId;
     }
 }

package/dist/m365/spo/commands/folder/FolderColor.js

@@ -0,0 +1,19 @@
+export const FolderColorValues = {
+    yellow: '0',
+    darkRed: '1',
+    darkOrange: '2',
+    darkGreen: '3',
+    darkTeal: '4',
+    darkBlue: '5',
+    darkPurple: '6',
+    darkPink: '7',
+    grey: '8',
+    lightRed: '9',
+    lightOrange: '10',
+    lightGreen: '11',
+    lightTeal: '12',
+    lightBlue: '13',
+    lightPurple: '14',
+    lightPink: '15'
+};
+//# sourceMappingURL=FolderColor.js.map

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

@@ -3,13 +3,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SpoFolderAddCommand_instances, _SpoFolderAddCommand_initOptions, _SpoFolderAddCommand_initValidators, _SpoFolderAddCommand_initTypes;
+var _SpoFolderAddCommand_instances, _SpoFolderAddCommand_initTelemetry, _SpoFolderAddCommand_initOptions, _SpoFolderAddCommand_initValidators, _SpoFolderAddCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
+import { FolderColorValues } from './FolderColor.js';
 class SpoFolderAddCommand extends SpoCommand {
     get name() {
         return commands.FOLDER_ADD;
@@ -20,25 +21,35 @@ class SpoFolderAddCommand extends SpoCommand {
     constructor() {
         super();
         _SpoFolderAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
-        if (this.verbose) {
-            await logger.logToStderr(`Adding folder to site ${args.options.webUrl}...`);
-        }
-        const parentFolderServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.parentFolderUrl);
-        const serverRelativeUrl = `${parentFolderServerRelativeUrl}/${args.options.name}`;
-        const requestUrl = `${args.options.webUrl}/_api/web/folders/addUsingPath(decodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}')`;
-        const requestOptions = {
-            url: requestUrl,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
         try {
+            if (this.verbose) {
+                await logger.logToStderr(`Adding folder to site ${args.options.webUrl}...`);
+            }
+            const parentFolderServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.parentFolderUrl);
+            const serverRelativeUrl = `${parentFolderServerRelativeUrl}/${args.options.name}`;
+            const requestOptions = {
+                headers: {
+                    'accept': 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            if (args.options.color === undefined) {
+                requestOptions.url = `${args.options.webUrl}/_api/web/folders/addUsingPath(decodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}')`;
+            }
+            else {
+                requestOptions.url = `${args.options.webUrl}/_api/foldercoloring/createfolder(DecodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}', overwrite=false)`;
+                requestOptions.data = {
+                    coloringInformation: {
+                        ColorHex: FolderColorValues[args.options.color] || args.options.color
+                    }
+                };
+            }
             const folder = await request.post(requestOptions);
             await logger.log(folder);
         }
@@ -47,18 +58,36 @@ class SpoFolderAddCommand extends SpoCommand {
         }
     }
 }
-_SpoFolderAddCommand_instances = new WeakSet(), _SpoFolderAddCommand_initOptions = function _SpoFolderAddCommand_initOptions() {
+_SpoFolderAddCommand_instances = new WeakSet(), _SpoFolderAddCommand_initTelemetry = function _SpoFolderAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            color: typeof args.options.color !== 'undefined'
+        });
+    });
+}, _SpoFolderAddCommand_initOptions = function _SpoFolderAddCommand_initOptions() {
     this.options.unshift({
         option: '-u, --webUrl <webUrl>'
     }, {
         option: '-p, --parentFolderUrl <parentFolderUrl>'
     }, {
         option: '-n, --name <name>'
+    }, {
+        option: '--color [color]',
+        autocomplete: Object.keys(FolderColorValues)
     });
 }, _SpoFolderAddCommand_initValidators = function _SpoFolderAddCommand_initValidators() {
-    this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.webUrl));
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.color && !Object.entries(FolderColorValues).flat().includes(args.options.color)) {
+            return `'${args.options.color}' is not a valid value for option 'color'. Allowed values are ${Object.keys(FolderColorValues).join(', ')}, ${Object.values(FolderColorValues).join(', ')}.`;
+        }
+        return true;
+    });
 }, _SpoFolderAddCommand_initTypes = function _SpoFolderAddCommand_initTypes() {
-    this.types.string.push('webUrl', 'parentFolderUrl', 'name');
+    this.types.string.push('webUrl', 'parentFolderUrl', 'name', 'color');
 };
 export default new SpoFolderAddCommand();
 //# sourceMappingURL=folder-add.js.map

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

@@ -0,0 +1,118 @@
+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 _SpoFolderSetCommand_instances, _SpoFolderSetCommand_initTelemetry, _SpoFolderSetCommand_initOptions, _SpoFolderSetCommand_initValidators, _SpoFolderSetCommand_initTypes;
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { FolderColorValues } from './FolderColor.js';
+class SpoFolderSetCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SET;
+    }
+    get description() {
+        return 'Updates a folder';
+    }
+    alias() {
+        return [commands.FOLDER_RENAME];
+    }
+    constructor() {
+        super();
+        _SpoFolderSetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initTypes).call(this);
+    }
+    getExcludedOptionsWithUrls() {
+        return ['url'];
+    }
+    async commandAction(logger, args) {
+        try {
+            await this.showDeprecationWarning(logger, this.alias()[0], this.name);
+            if (this.verbose) {
+                await logger.logToStderr(`Updating folder '${args.options.name}'...`);
+            }
+            const serverRelativePath = urlUtil.getServerRelativePath(args.options.webUrl, args.options.url);
+            if (!args.options.color) {
+                const requestOptions = {
+                    url: `${args.options.webUrl}/_api/Web/GetFolderByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(serverRelativePath)}')/ListItemAllFields`,
+                    headers: {
+                        accept: 'application/json;odata=nometadata',
+                        'if-match': '*'
+                    },
+                    data: {
+                        FileLeafRef: args.options.name,
+                        Title: args.options.name
+                    },
+                    responseType: 'json'
+                };
+                const response = await request.patch(requestOptions);
+                if (response && response['odata.null'] === true) {
+                    throw 'Folder not found.';
+                }
+            }
+            else {
+                const requestOptions = {
+                    url: `${args.options.webUrl}/_api/foldercoloring/${args.options.name ? 'renamefolder' : 'stampcolor'}(DecodedUrl='${formatting.encodeQueryParameter(serverRelativePath)}')`,
+                    headers: {
+                        accept: 'application/json;odata=nometadata'
+                    },
+                    responseType: 'json',
+                    data: {
+                        coloringInformation: {
+                            ColorHex: FolderColorValues[args.options.color] || args.options.color
+                        },
+                        newName: args.options.name
+                    }
+                };
+                await request.post(requestOptions);
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_SpoFolderSetCommand_instances = new WeakSet(), _SpoFolderSetCommand_initTelemetry = function _SpoFolderSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            name: typeof args.options.name !== 'undefined',
+            color: typeof args.options.color !== 'undefined'
+        });
+    });
+}, _SpoFolderSetCommand_initOptions = function _SpoFolderSetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
+        option: '--url <url>'
+    }, {
+        option: '-n, --name [name]'
+    }, {
+        option: '--color [color]',
+        autocomplete: Object.keys(FolderColorValues)
+    });
+}, _SpoFolderSetCommand_initValidators = function _SpoFolderSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.color === undefined && args.options.name === undefined) {
+            return `Specify at least one of the options: name or color.`;
+        }
+        if (args.options.color && !Object.entries(FolderColorValues).flat().includes(args.options.color)) {
+            return `'${args.options.color}' is not a valid value for option 'color'. Allowed values are ${Object.keys(FolderColorValues).join(', ')}, ${Object.values(FolderColorValues).join(', ')}.`;
+        }
+        return true;
+    });
+}, _SpoFolderSetCommand_initTypes = function _SpoFolderSetCommand_initTypes() {
+    this.types.string.push('webUrl', 'url', 'name', 'color');
+};
+export default new SpoFolderSetCommand();
+//# sourceMappingURL=folder-set.js.map

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

@@ -109,14 +109,14 @@ class SpoGroupMemberAddCommand extends SpoCommand {
                 }
                 else if (args.options.entraGroupNames) {
                     if (this.verbose) {
-                        await logger.logToStderr(`Getting ID of Azure AD group ${trimmedIdentifier}`);
+                        await logger.logToStderr(`Getting ID of Microsoft Entra group ${trimmedIdentifier}`);
                     }
                     const groupId = await entraGroup.getGroupIdByDisplayName(trimmedIdentifier);
                     validUserNames.push(groupId);
                 }
                 else {
                     if (this.verbose) {
-                        await logger.logToStderr(`Getting Azure AD ID for user ${trimmedIdentifier}`);
+                        await logger.logToStderr(`Getting Microsoft Entra ID for user ${trimmedIdentifier}`);
                     }
                     const upn = await entraUser.getUserIdByEmail(trimmedIdentifier);
                     validUserNames.push(upn);

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

@@ -122,7 +122,7 @@ class SpoGroupMemberRemoveCommand extends SpoCommand {
             foundGroups = getGroupMemberListOutput.filter((x) => { return x.Title === args.options.entraGroupName && (x.LoginName.indexOf("c:0o.c|federateddirectoryclaimprovider|") === 0 || x.LoginName.indexOf("c:0t.c|tenant|") === 0); });
         }
         if (foundGroups.length === 0) {
-            throw `The Azure AD group ${args.options.entraGroupId || args.options.entraGroupName} is not found in SharePoint group ${args.options.groupId || args.options.groupName}`;
+            throw `The Microsoft Entra group ${args.options.entraGroupId || args.options.entraGroupName} is not found in SharePoint group ${args.options.groupId || args.options.groupName}`;
         }
         return foundGroups[0].Id;
     }

package/dist/m365/spo/commands/site/site-apppermission-add.js

@@ -51,10 +51,10 @@ class SpoSiteAppPermissionAddCommand extends GraphCommand {
         const response = await request.get(appRequestOptions);
         const appItem = response.value[0];
         if (!appItem) {
-            throw "The specified Azure AD app does not exist";
+            throw "The specified Microsoft Entra app does not exist";
         }
         if (response.value.length > 1) {
-            throw `Multiple Azure AD app with displayName ${args.options.appDisplayName} found: ${response.value.map(x => x.appId)}`;
+            throw `Multiple Microsoft Entra apps with displayName ${args.options.appDisplayName} found: ${response.value.map(x => x.appId)}`;
         }
         return {
             appId: appItem.appId,

package/dist/m365/spo/commands/site/site-recyclebinitem-restore.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SpoSiteRecycleBinItemRestoreCommand_instances, _SpoSiteRecycleBinItemRestoreCommand_initOptions, _SpoSiteRecycleBinItemRestoreCommand_initValidators;
+var _SpoSiteRecycleBinItemRestoreCommand_instances, _SpoSiteRecycleBinItemRestoreCommand_initOptions, _SpoSiteRecycleBinItemRestoreCommand_initValidators, _SpoSiteRecycleBinItemRestoreCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
@@ -21,43 +21,73 @@ class SpoSiteRecycleBinItemRestoreCommand extends SpoCommand {
         _SpoSiteRecycleBinItemRestoreCommand_instances.add(this);
         __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         if (this.verbose) {
             await logger.logToStderr(`Restoring items from recycle bin at ${args.options.siteUrl}...`);
         }
-        const requestUrl = `${args.options.siteUrl}/_api/site/RecycleBin/RestoreByIds`;
-        const ids = formatting.splitAndTrim(args.options.ids);
-        const idsChunks = [];
-        while (ids.length) {
-            idsChunks.push(ids.splice(0, 20));
-        }
+        const baseUrl = `${args.options.siteUrl}/_api`;
         try {
-            await Promise.all(idsChunks.map((idsChunk) => {
-                const requestOptions = {
-                    url: requestUrl,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata',
-                        'content-type': 'application/json'
-                    },
-                    responseType: 'json',
-                    data: {
-                        ids: idsChunk
-                    }
-                };
-                return request.post(requestOptions);
-            }));
+            if (args.options.ids) {
+                const requestUrl = baseUrl + '/site/RecycleBin/RestoreByIds';
+                const ids = formatting.splitAndTrim(args.options.ids);
+                const idsChunks = [];
+                while (ids.length) {
+                    idsChunks.push(ids.splice(0, 20));
+                }
+                await Promise.all(idsChunks.map((idsChunk) => {
+                    const requestOptions = {
+                        url: requestUrl,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata',
+                            'content-type': 'application/json'
+                        },
+                        responseType: 'json',
+                        data: {
+                            ids: idsChunk
+                        }
+                    };
+                    return request.post(requestOptions);
+                }));
+            }
+            else {
+                if (args.options.allPrimary && args.options.allSecondary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/site/RecycleBin/RestoreAll');
+                }
+                else if (args.options.allPrimary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/web/RecycleBin/RestoreAll');
+                }
+                else if (args.options.allSecondary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/site/GetRecycleBinItems(rowLimit=2000000000,itemState=2)/RestoreAll');
+                }
+            }
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
+    async restoreRecycleBinStage(requestUrl) {
+        const requestOptions = {
+            url: requestUrl,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json'
+            },
+            responseType: 'json'
+        };
+        return request.post(requestOptions);
+    }
 }
 _SpoSiteRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoSiteRecycleBinItemRestoreCommand_initOptions = function _SpoSiteRecycleBinItemRestoreCommand_initOptions() {
     this.options.unshift({
         option: '-u, --siteUrl <siteUrl>'
     }, {
-        option: '-i, --ids <ids>'
+        option: '-i, --ids [ids]'
+    }, {
+        option: '--allPrimary'
+    }, {
+        option: '--allSecondary'
     });
 }, _SpoSiteRecycleBinItemRestoreCommand_initValidators = function _SpoSiteRecycleBinItemRestoreCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -65,14 +95,23 @@ _SpoSiteRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoSiteRecycleB
         if (isValidSharePointUrl !== true) {
             return isValidSharePointUrl;
         }
-        const invalidIds = formatting
-            .splitAndTrim(args.options.ids)
-            .filter(id => !validation.isValidGuid(id));
-        if (invalidIds.length > 0) {
-            return `The following IDs are invalid: ${invalidIds.join(', ')}`;
+        if (args.options.ids) {
+            const invalidIds = formatting
+                .splitAndTrim(args.options.ids)
+                .filter(id => !validation.isValidGuid(id));
+            if (invalidIds.length > 0) {
+                return `The following IDs are invalid: ${invalidIds.join(', ')}`;
+            }
+        }
+        if ((!args.options.ids && !args.options.allPrimary && !args.options.allSecondary)
+            || (args.options.ids && (args.options.allPrimary || args.options.allSecondary))) {
+            return `Option 'ids' cannot be used with 'allPrimary' or 'allSecondary'.`;
         }
         return true;
     });
+}, _SpoSiteRecycleBinItemRestoreCommand_initTypes = function _SpoSiteRecycleBinItemRestoreCommand_initTypes() {
+    this.types.string.push('siteUrl', 'ids');
+    this.types.boolean.push('allPrimary', 'allSecondary');
 };
 export default new SpoSiteRecycleBinItemRestoreCommand();
 //# sourceMappingURL=site-recyclebinitem-restore.js.map

package/dist/m365/spo/commands/tenant/tenant-settings-set.js

@@ -89,7 +89,7 @@ class SpoTenantSettingsSetCommand extends SpoCommand {
                 throw response.ErrorInfo.ErrorMessage;
             }
             if (args.options.EnableAzureADB2BIntegration === true) {
-                await this.warn(logger, 'WARNING: Make sure to also enable the Azure AD one-time passcode authentication preview. If it is not enabled then SharePoint will not use Azure AD B2B even if EnableAzureADB2BIntegration is set to true. Learn more at http://aka.ms/spo-b2b-integration.');
+                await this.warn(logger, 'WARNING: Make sure to also enable the Microsoft Entra one-time passcode authentication preview. If it is not enabled then SharePoint will not use Microsoft Entra B2B even if EnableAzureADB2BIntegration is set to true. Learn more at http://aka.ms/spo-b2b-integration.');
             }
         }
         catch (err) {

package/dist/m365/spo/commands.js

@@ -91,6 +91,7 @@ export default {
     FOLDER_MOVE: `${prefix} folder move`,
     FOLDER_REMOVE: `${prefix} folder remove`,
     FOLDER_RENAME: `${prefix} folder rename`,
+    FOLDER_SET: `${prefix} folder set`,
     FOLDER_RETENTIONLABEL_ENSURE: `${prefix} folder retentionlabel ensure`,
     FOLDER_RETENTIONLABEL_REMOVE: `${prefix} folder retentionlabel remove`,
     FOLDER_ROLEASSIGNMENT_REMOVE: `${prefix} folder roleassignment remove`,

package/dist/m365/teams/commands/tab/tab-get.js

@@ -78,7 +78,7 @@ class TeamsTabGetCommand extends GraphCommand {
             this.teamId = await this.getTeamId(args);
             this.channelId = await this.getChannelId(args);
             const tabId = await this.getTabId(args);
-            const endpoint = `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(this.teamId)}/channels/${formatting.encodeQueryParameter(this.channelId)}/tabs/${formatting.encodeQueryParameter(tabId)}`;
+            const endpoint = `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(this.teamId)}/channels/${formatting.encodeQueryParameter(this.channelId)}/tabs/${formatting.encodeQueryParameter(tabId)}?$expand=teamsApp`;
             const requestOptions = {
                 url: endpoint,
                 headers: {

package/dist/utils/spo.js

@@ -490,7 +490,7 @@ export const spo = {
         return result.CorporateCatalogUrl;
     },
     /**
-     * Retrieves the Azure AD ID from a SP user.
+     * Retrieves the Microsoft Entra ID from a SP user.
      * @param webUrl Web url
      * @param id The Id of the user
      */