@pnp/cli-microsoft365 9.0.0-beta.2f8dd1e → 9.0.0-beta.59b026e

package/dist/m365/spo/commands/tenant/tenant-commandset-get.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 _SpoTenantCommandSetGetCommand_instances, _SpoTenantCommandSetGetCommand_initTelemetry, _SpoTenantCommandSetGetCommand_initOptions, _SpoTenantCommandSetGetCommand_initValidators, _SpoTenantCommandSetGetCommand_initOptionSets;
+var _SpoTenantCommandSetGetCommand_instances, _SpoTenantCommandSetGetCommand_initTelemetry, _SpoTenantCommandSetGetCommand_initOptions, _SpoTenantCommandSetGetCommand_initValidators, _SpoTenantCommandSetGetCommand_initOptionSets, _SpoTenantCommandSetGetCommand_initTypes;
 import { cli } from '../../../../cli/cli.js';
 import { CommandError } from '../../../../Command.js';
 import request from '../../../../request.js';
@@ -27,6 +27,7 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         const appCatalogUrl = await spo.getTenantAppCatalogUrl(logger, this.debug);
@@ -47,7 +48,7 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
         const reqOptions = {
             url: `${appCatalogUrl}/_api/web/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')/items?$filter=${filter}`,
             headers: {
-                'accept': 'application/json;odata=nometadata'
+                accept: 'application/json;odata=nometadata'
             },
             responseType: 'json'
         };
@@ -55,13 +56,20 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
             const listItemInstances = await request.get(reqOptions);
             if (listItemInstances?.value.length > 0) {
                 listItemInstances.value.forEach(v => delete v['ID']);
+                let listItemInstance;
                 if (listItemInstances.value.length > 1) {
                     const resultAsKeyValuePair = formatting.convertArrayToHashTable('Id', listItemInstances.value);
-                    const result = await cli.handleMultipleResultsFound(`Multiple ListView Command Sets with ${args.options.title || args.options.clientSideComponentId} were found.`, resultAsKeyValuePair);
-                    await logger.log(result);
+                    listItemInstance = await cli.handleMultipleResultsFound(`Multiple ListView Command Sets with ${args.options.title || args.options.clientSideComponentId} were found.`, resultAsKeyValuePair);
                 }
                 else {
-                    await logger.log(listItemInstances.value[0]);
+                    listItemInstance = listItemInstances.value[0];
+                }
+                if (!args.options.tenantWideExtensionComponentProperties) {
+                    await logger.log(listItemInstance);
+                }
+                else {
+                    const properties = formatting.tryParseJson(listItemInstance.TenantWideExtensionComponentProperties);
+                    await logger.log(properties);
                 }
             }
             else {
@@ -78,7 +86,8 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
         Object.assign(this.telemetryProperties, {
             title: typeof args.options.title !== 'undefined',
             id: typeof args.options.id !== 'undefined',
-            clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined'
+            clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined',
+            tenantWideExtensionComponentProperties: !!args.options.tenantWideExtensionComponentProperties
         });
     });
 }, _SpoTenantCommandSetGetCommand_initOptions = function _SpoTenantCommandSetGetCommand_initOptions() {
@@ -88,6 +97,8 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
         option: '-i, --id [id]'
     }, {
         option: '-c, --clientSideComponentId  [clientSideComponentId]'
+    }, {
+        option: '-p, --tenantWideExtensionComponentProperties'
     });
 }, _SpoTenantCommandSetGetCommand_initValidators = function _SpoTenantCommandSetGetCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -101,6 +112,9 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
     });
 }, _SpoTenantCommandSetGetCommand_initOptionSets = function _SpoTenantCommandSetGetCommand_initOptionSets() {
     this.optionSets.push({ options: ['title', 'id', 'clientSideComponentId'] });
+}, _SpoTenantCommandSetGetCommand_initTypes = function _SpoTenantCommandSetGetCommand_initTypes() {
+    this.types.string.push('title', 'id', 'clientSideComponentId');
+    this.types.boolean.push('tenantWideExtensionComponentProperties');
 };
 export default new SpoTenantCommandSetGetCommand();
 //# sourceMappingURL=tenant-commandset-get.js.map

package/dist/m365/spo/commands/tenant/tenant-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 _SpoTenantRecycleBinItemRestoreCommand_instances, _SpoTenantRecycleBinItemRestoreCommand_initTelemetry, _SpoTenantRecycleBinItemRestoreCommand_initOptions, _SpoTenantRecycleBinItemRestoreCommand_initValidators, _SpoTenantRecycleBinItemRestoreCommand_initTypes;
+var _SpoTenantRecycleBinItemRestoreCommand_instances, _SpoTenantRecycleBinItemRestoreCommand_initOptions, _SpoTenantRecycleBinItemRestoreCommand_initValidators, _SpoTenantRecycleBinItemRestoreCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
@@ -22,15 +22,11 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
     constructor() {
         super();
         _SpoTenantRecycleBinItemRestoreCommand_instances.add(this);
-        __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
-        if (args.options.wait) {
-            await this.warn(logger, `Option 'wait' is deprecated and will be removed in the next major release.`);
-        }
         try {
             if (this.verbose) {
                 await logger.logToStderr(`Restoring site collection '${args.options.siteUrl}' from recycle bin.`);
@@ -62,13 +58,6 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
                 };
                 await request.post(restoreOptions);
             }
-            // Here, we return a fixed response because this new API endpoint doesn't return a response while the previous API did.
-            // This has to be removed in the next major release.
-            await logger.log({
-                HasTimedout: false,
-                IsComplete: !!args.options.wait,
-                PollingInterval: 15000
-            });
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
@@ -79,23 +68,14 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
         return sites[0].GroupId;
     }
 }
-_SpoTenantRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoTenantRecycleBinItemRestoreCommand_initTelemetry = function _SpoTenantRecycleBinItemRestoreCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            wait: !!args.options.wait
-        });
-    });
-}, _SpoTenantRecycleBinItemRestoreCommand_initOptions = function _SpoTenantRecycleBinItemRestoreCommand_initOptions() {
+_SpoTenantRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoTenantRecycleBinItemRestoreCommand_initOptions = function _SpoTenantRecycleBinItemRestoreCommand_initOptions() {
     this.options.unshift({
         option: '-u, --siteUrl <siteUrl>'
-    }, {
-        option: '--wait'
     });
 }, _SpoTenantRecycleBinItemRestoreCommand_initValidators = function _SpoTenantRecycleBinItemRestoreCommand_initValidators() {
     this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.siteUrl));
 }, _SpoTenantRecycleBinItemRestoreCommand_initTypes = function _SpoTenantRecycleBinItemRestoreCommand_initTypes() {
     this.types.string.push('siteUrl');
-    this.types.boolean.push('wait');
 };
 export default new SpoTenantRecycleBinItemRestoreCommand();
 //# sourceMappingURL=tenant-recyclebinitem-restore.js.map

package/dist/m365/spo/commands.js

@@ -31,6 +31,7 @@ export default {
     COMMANDSET_REMOVE: `${prefix} commandset remove`,
     COMMANDSET_SET: `${prefix} commandset set`,
     CONTENTTYPE_ADD: `${prefix} contenttype add`,
+    CONTENTTYPE_FIELD_LIST: `${prefix} contenttype field list`,
     CONTENTTYPE_FIELD_REMOVE: `${prefix} contenttype field remove`,
     CONTENTTYPE_FIELD_SET: `${prefix} contenttype field set`,
     CONTENTTYPE_GET: `${prefix} contenttype get`,
@@ -91,7 +92,6 @@ export default {
     FOLDER_LIST: `${prefix} folder list`,
     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`,
@@ -99,6 +99,8 @@ export default {
     FOLDER_ROLEASSIGNMENT_ADD: `${prefix} folder roleassignment add`,
     FOLDER_ROLEINHERITANCE_BREAK: `${prefix} folder roleinheritance break`,
     FOLDER_ROLEINHERITANCE_RESET: `${prefix} folder roleinheritance reset`,
+    FOLDER_SHARINGLINK_GET: `${prefix} folder sharinglink get`,
+    FOLDER_SHARINGLINK_LIST: `${prefix} folder sharinglink list`,
     GET: `${prefix} get`,
     GROUP_ADD: `${prefix} group add`,
     GROUP_GET: `${prefix} group get`,

package/dist/m365/teams/commands/meeting/meeting-attendancereport-get.js

@@ -0,0 +1,119 @@
+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 _TeamsMeetingAttendancereportGetCommand_instances, _TeamsMeetingAttendancereportGetCommand_initTelemetry, _TeamsMeetingAttendancereportGetCommand_initOptions, _TeamsMeetingAttendancereportGetCommand_initTypes, _TeamsMeetingAttendancereportGetCommand_initValidators, _TeamsMeetingAttendancereportGetCommand_initOptionSets;
+import auth from '../../../../Auth.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from '../../commands.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import request from '../../../../request.js';
+class TeamsMeetingAttendancereportGetCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_ATTENDANCEREPORT_GET;
+    }
+    get description() {
+        return 'Gets attendance report for a given meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingAttendancereportGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+            if (isAppOnlyAccessToken && !args.options.userId && !args.options.userName && !args.options.email) {
+                throw `The option 'userId', 'userName' or 'email' is required when retrieving meeting attendance report using app only permissions.`;
+            }
+            else if (!isAppOnlyAccessToken && (args.options.userId || args.options.userName || args.options.email)) {
+                throw `The options 'userId', 'userName' and 'email' cannot be used when retrieving meeting attendance report using delegated permissions.`;
+            }
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving attendance report for ${isAppOnlyAccessToken ? `specific user ${args.options.userId || args.options.userName || args.options.email}.` : 'currently logged in user'}.`);
+            }
+            let userUrl = '';
+            if (isAppOnlyAccessToken) {
+                const userId = await this.getUserId(args.options);
+                userUrl += `users/${userId}`;
+            }
+            else {
+                userUrl += 'me';
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/${userUrl}/onlineMeetings/${args.options.meetingId}/attendanceReports/${args.options.id}?$expand=attendanceRecords`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const attendanceReport = await request.get(requestOptions);
+            await logger.log(attendanceReport);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getUserId(options) {
+        if (options.userId) {
+            return options.userId;
+        }
+        if (options.userName) {
+            return entraUser.getUserIdByUpn(options.userName);
+        }
+        return entraUser.getUserIdByEmail(options.email);
+    }
+}
+_TeamsMeetingAttendancereportGetCommand_instances = new WeakSet(), _TeamsMeetingAttendancereportGetCommand_initTelemetry = function _TeamsMeetingAttendancereportGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            email: typeof args.options.email !== 'undefined'
+        });
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initOptions = function _TeamsMeetingAttendancereportGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--email [email]'
+    }, {
+        option: '-m, --meetingId <meetingId>'
+    }, {
+        option: '-i, --id <id>'
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initTypes = function _TeamsMeetingAttendancereportGetCommand_initTypes() {
+    this.types.string.push('userId', 'userName', 'email', 'meetingId', 'id');
+}, _TeamsMeetingAttendancereportGetCommand_initValidators = function _TeamsMeetingAttendancereportGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (!validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID for option 'id'.`;
+        }
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid GUID for option 'userId'.`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid UPN.`;
+        }
+        if (args.options.email && !validation.isValidUserPrincipalName(args.options.email)) {
+            return `${args.options.email} is not a valid email.`;
+        }
+        return true;
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initOptionSets = function _TeamsMeetingAttendancereportGetCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['userId', 'userName', 'email'],
+        runsWhen: (args) => args.options.userId || args.options.userName || args.options.email
+    });
+};
+export default new TeamsMeetingAttendancereportGetCommand();
+//# sourceMappingURL=meeting-attendancereport-get.js.map

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

@@ -0,0 +1,112 @@
+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 _TeamsMessageRemoveCommand_instances, _TeamsMessageRemoveCommand_initTelemetry, _TeamsMessageRemoveCommand_initOptions, _TeamsMessageRemoveCommand_initValidators, _TeamsMessageRemoveCommand_initOptionSets, _TeamsMessageRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { teams } from '../../../../utils/teams.js';
+import { validation } from '../../../../utils/validation.js';
+import DelegatedGraphCommand from '../../../base/DelegatedGraphCommand.js';
+import commands from '../../commands.js';
+class TeamsMessageRemoveCommand extends DelegatedGraphCommand {
+    get name() {
+        return commands.MESSAGE_REMOVE;
+    }
+    get description() {
+        return 'Removes a message from a channel in a Microsoft Teams team';
+    }
+    constructor() {
+        super();
+        _TeamsMessageRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeTeamMessage = async () => {
+            try {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing message '${args.options.id}' from channel '${args.options.channelId || args.options.channelName}' in team '${args.options.teamId || args.options.teamName}'.`);
+                }
+                const teamId = args.options.teamId || await teams.getTeamIdByDisplayName(args.options.teamName);
+                const channelId = args.options.channelId || await teams.getChannelIdByDisplayName(teamId, args.options.channelName);
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/teams/${teamId}/channels/${formatting.encodeQueryParameter(channelId)}/messages/${args.options.id}/softDelete`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                await request.post(requestOptions);
+            }
+            catch (err) {
+                if (err.error?.error?.code === 'NotFound') {
+                    this.handleError('The message was not found in the Teams channel.');
+                }
+                else {
+                    this.handleRejectedODataJsonPromise(err);
+                }
+            }
+        };
+        if (args.options.force) {
+            await removeTeamMessage();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove this message?` });
+            if (result) {
+                await removeTeamMessage();
+            }
+        }
+    }
+}
+_TeamsMessageRemoveCommand_instances = new WeakSet(), _TeamsMessageRemoveCommand_initTelemetry = function _TeamsMessageRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            teamId: typeof args.options.teamId !== 'undefined',
+            teamName: typeof args.options.teamName !== 'undefined',
+            channelId: typeof args.options.channelId !== 'undefined',
+            channelName: typeof args.options.channelName !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _TeamsMessageRemoveCommand_initOptions = function _TeamsMessageRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
+    }, {
+        option: '--channelId [channelId]'
+    }, {
+        option: '--channelName [channelName]'
+    }, {
+        option: '-i, --id <id>'
+    }, {
+        option: '-f, --force'
+    });
+}, _TeamsMessageRemoveCommand_initValidators = function _TeamsMessageRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
+            return `'${args.options.teamId}' is not a valid GUID for 'teamId'.`;
+        }
+        if (args.options.channelId && !validation.isValidTeamsChannelId(args.options.channelId)) {
+            return `'${args.options.channelId}' is not a valid ID for 'channelId'.`;
+        }
+        return true;
+    });
+}, _TeamsMessageRemoveCommand_initOptionSets = function _TeamsMessageRemoveCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['teamId', 'teamName']
+    }, {
+        options: ['channelId', 'channelName']
+    });
+}, _TeamsMessageRemoveCommand_initTypes = function _TeamsMessageRemoveCommand_initTypes() {
+    this.types.string.push('teamId', 'teamName', 'channelId', 'channelName', 'id');
+    this.types.boolean.push('force');
+};
+export default new TeamsMessageRemoveCommand();
+//# sourceMappingURL=message-remove.js.map

package/dist/m365/teams/commands.js

@@ -30,12 +30,14 @@ export default {
     MEETING_ADD: `${prefix} meeting add`,
     MEETING_GET: `${prefix} meeting get`,
     MEETING_LIST: `${prefix} meeting list`,
+    MEETING_ATTENDANCEREPORT_GET: `${prefix} meeting attendancereport get`,
     MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,
     MESSAGE_GET: `${prefix} message get`,
     MESSAGE_LIST: `${prefix} message list`,
+    MESSAGE_REMOVE: `${prefix} message remove`,
     MESSAGE_REPLY_LIST: `${prefix} message reply list`,
     MESSAGE_SEND: `${prefix} message send`,
     MESSAGINGSETTINGS_LIST: `${prefix} messagingsettings list`,

package/dist/m365/viva/commands/engage/engage-community-add.js

@@ -0,0 +1,166 @@
+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 _VivaEngageCommunityAddCommand_instances, _VivaEngageCommunityAddCommand_initTelemetry, _VivaEngageCommunityAddCommand_initOptions, _VivaEngageCommunityAddCommand_initValidators, _VivaEngageCommunityAddCommand_initTypes, _VivaEngageCommunityAddCommand_initOptionSets;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import auth from '../../../../Auth.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { setTimeout } from 'timers/promises';
+class VivaEngageCommunityAddCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_ADD;
+    }
+    get description() {
+        return 'Creates a new community in Viva Engage';
+    }
+    constructor() {
+        super();
+        _VivaEngageCommunityAddCommand_instances.add(this);
+        this.pollingInterval = 5000;
+        this.privacyOptions = ['public', 'private'];
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        const { displayName, description, privacy, adminEntraIds, adminEntraUserNames, wait } = args.options;
+        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+        if (isAppOnlyAccessToken && !adminEntraIds && !adminEntraUserNames) {
+            this.handleError(`Specify at least one admin using either adminEntraIds or adminEntraUserNames options when using application permissions.`);
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Creating a Viva Engage community with display name '${displayName}'...`);
+        }
+        try {
+            const requestOptions = {
+                url: `${this.resource}/beta/employeeExperience/communities`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    'content-type': 'application/json'
+                },
+                responseType: 'json',
+                fullResponse: true,
+                data: {
+                    displayName: displayName,
+                    description: description,
+                    privacy: privacy
+                }
+            };
+            const entraIds = await this.getGraphUserUrls(args.options);
+            if (entraIds.length > 0) {
+                requestOptions.data['owners@odata.bind'] = entraIds;
+            }
+            const res = await request.post(requestOptions);
+            const location = res.headers.location;
+            if (!wait) {
+                await logger.log(location);
+                return;
+            }
+            let status;
+            do {
+                if (this.verbose) {
+                    await logger.logToStderr(`Community still provisioning. Retrying in ${this.pollingInterval / 1000} seconds...`);
+                }
+                await setTimeout(this.pollingInterval);
+                if (this.verbose) {
+                    await logger.logToStderr(`Checking create community operation status...`);
+                }
+                const operation = await request.get({
+                    url: location,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                });
+                status = operation.status;
+                if (this.verbose) {
+                    await logger.logToStderr(`Community creation operation status: ${status}`);
+                }
+                if (status === 'failed') {
+                    throw `Community creation failed: ${operation.statusDetail}`;
+                }
+                if (status === 'succeeded') {
+                    await logger.log(operation);
+                }
+            } while (status === 'notStarted' || status === 'running');
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getGraphUserUrls(options) {
+        let entraIds = [];
+        if (options.adminEntraIds) {
+            entraIds = formatting.splitAndTrim(options.adminEntraIds);
+        }
+        else if (options.adminEntraUserNames) {
+            entraIds = await entraUser.getUserIdsByUpns(formatting.splitAndTrim(options.adminEntraUserNames));
+        }
+        const graphUserUrls = entraIds.map(id => `${this.resource}/beta/users/${id}`);
+        return graphUserUrls;
+    }
+}
+_VivaEngageCommunityAddCommand_instances = new WeakSet(), _VivaEngageCommunityAddCommand_initTelemetry = function _VivaEngageCommunityAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            adminEntraIds: typeof args.options.adminEntraIds !== 'undefined',
+            adminEntraUserNames: typeof args.options.adminEntraUserNames !== 'undefined',
+            wait: !!args.options.wait
+        });
+    });
+}, _VivaEngageCommunityAddCommand_initOptions = function _VivaEngageCommunityAddCommand_initOptions() {
+    this.options.unshift({ option: '--displayName <displayName>' }, { option: '--description <description>' }, {
+        option: '--privacy <privacy>',
+        autocomplete: this.privacyOptions
+    }, { option: '--adminEntraIds [adminEntraIds]' }, { option: '--adminEntraUserNames [adminEntraUserNames]' }, { option: '--wait' });
+}, _VivaEngageCommunityAddCommand_initValidators = function _VivaEngageCommunityAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.displayName.length > 255) {
+            return `The maximum amount of characters for 'displayName' is 255.`;
+        }
+        if (args.options.description.length > 1024) {
+            return `The maximum amount of characters for 'description' is 1024.`;
+        }
+        if (this.privacyOptions.indexOf(args.options.privacy) === -1) {
+            return `'${args.options.privacy}' is not a valid value for privacy. Allowed values are: ${this.privacyOptions.join(', ')}.`;
+        }
+        if (args.options.adminEntraIds) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.adminEntraIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'adminEntraIds': ${isValidGUIDArrayResult}.`;
+            }
+            if (formatting.splitAndTrim(args.options.adminEntraIds).length > 20) {
+                return `Maximum of 20 admins allowed. Please reduce the number of users and try again.`;
+            }
+        }
+        if (args.options.adminEntraUserNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.adminEntraUserNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for the option 'adminEntraUserNames': ${isValidUPNArrayResult}.`;
+            }
+            if (formatting.splitAndTrim(args.options.adminEntraUserNames).length > 20) {
+                return `Maximum of 20 admins allowed. Please reduce the number of users and try again.`;
+            }
+        }
+        return true;
+    });
+}, _VivaEngageCommunityAddCommand_initTypes = function _VivaEngageCommunityAddCommand_initTypes() {
+    this.types.string.push('displayName', 'description', 'privacy', 'adminEntraIds', 'adminEntraUserNames');
+    this.types.boolean.push('wait');
+}, _VivaEngageCommunityAddCommand_initOptionSets = function _VivaEngageCommunityAddCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['adminEntraIds', 'adminEntraUserNames'],
+        runsWhen: (args) => args.options.adminEntraIds || args.options.adminEntraUserNames
+    });
+};
+export default new VivaEngageCommunityAddCommand();
+//# sourceMappingURL=engage-community-add.js.map

package/dist/m365/viva/commands.js

@@ -1,6 +1,7 @@
 const prefix = 'viva';
 export default {
     CONNECTIONS_APP_CREATE: `${prefix} connections app create`,
+    ENGAGE_COMMUNITY_ADD: `${prefix} engage community add`,
     ENGAGE_COMMUNITY_GET: `${prefix} engage community get`,
     ENGAGE_GROUP_LIST: `${prefix} engage group list`,
     ENGAGE_GROUP_USER_ADD: `${prefix} engage group user add`,

package/dist/utils/drive.js

@@ -0,0 +1,61 @@
+import request from "../request.js";
+export const drive = {
+    /**
+     * Retrieves the Drive associated with the specified site and URL.
+     * @param siteId Site ID
+     * @param url Drive URL
+     * @param logger The logger object
+     * @param verbose Set for verbose logging
+     * @returns The Drive associated with the drive URL.
+     */
+    async getDriveByUrl(siteId, url, logger, verbose) {
+        if (verbose && logger) {
+            await logger.logToStderr(`Retrieving drive information for URL: ${url.href}`);
+        }
+        const requestOptions = {
+            url: `https://graph.microsoft.com/v1.0/sites/${siteId}/drives?$select=webUrl,id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const drives = await request.get(requestOptions);
+        const lowerCaseFolderUrl = url.href.toLowerCase();
+        const drive = drives.value
+            .sort((a, b) => b.webUrl.localeCompare(a.webUrl))
+            .find((d) => {
+            const driveUrl = d.webUrl.toLowerCase();
+            return lowerCaseFolderUrl.startsWith(driveUrl) &&
+                (driveUrl.length === lowerCaseFolderUrl.length ||
+                    lowerCaseFolderUrl[driveUrl.length] === '/');
+        });
+        if (!drive) {
+            throw new Error(`Drive '${url.href}' not found`);
+        }
+        return drive;
+    },
+    /**
+     * Retrieves the ID of a drive item (file, folder, etc.) associated with the given drive and item URL.
+     * @param drive The Drive object containing the item
+     * @param itemUrl Item URL
+     * @param logger The logger object
+     * @param verbose Set for verbose logging
+     * @returns Drive item ID
+     */
+    async getDriveItemId(drive, itemUrl, logger, verbose) {
+        const relativeItemUrl = itemUrl.href.replace(new RegExp(`${drive.webUrl}`, 'i'), '').replace(/\/+$/, '');
+        if (verbose && logger) {
+            await logger.logToStderr(`Retrieving drive item ID for URL: ${relativeItemUrl}`);
+        }
+        const requestOptions = {
+            url: `https://graph.microsoft.com/v1.0/drives/${drive.id}/root${relativeItemUrl ? `:${relativeItemUrl}` : ''}?$select=id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const driveItem = await request.get(requestOptions);
+        return driveItem?.id;
+    }
+};
+//# sourceMappingURL=drive.js.map