@pnp/cli-microsoft365 8.0.0-beta.e6f9331 → 8.1.0-beta.309a9b8

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/message/message-restore.js

@@ -0,0 +1,106 @@
+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 _TeamsMessageRestoreCommand_instances, _TeamsMessageRestoreCommand_initTelemetry, _TeamsMessageRestoreCommand_initOptions, _TeamsMessageRestoreCommand_initValidators, _TeamsMessageRestoreCommand_initOptionSets, _TeamsMessageRestoreCommand_initTypes;
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import commands from '../../commands.js';
+import DelegatedGraphCommand from '../../../base/DelegatedGraphCommand.js';
+import { teams } from '../../../../utils/teams.js';
+class TeamsMessageRestoreCommand extends DelegatedGraphCommand {
+    get name() {
+        return commands.MESSAGE_RESTORE;
+    }
+    get description() {
+        return 'Restores a deleted message from a channel in a Microsoft Teams team';
+    }
+    constructor() {
+        super();
+        _TeamsMessageRestoreCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Restoring deleted message '${args.options.id}' from channel '${args.options.channelId || args.options.channelName}' in the Microsoft Teams team '${args.options.teamId || args.options.teamName}'.`);
+            }
+            const teamId = await this.getTeamId(args.options, logger);
+            const channelId = await this.getChannelId(args.options, teamId, logger);
+            const requestOptions = {
+                url: `${this.resource}/v1.0/teams/${teamId}/channels/${channelId}/messages/${args.options.id}/undoSoftDelete`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            await request.post(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getTeamId(options, logger) {
+        if (options.teamId) {
+            return options.teamId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the Team ID.`);
+        }
+        const groupId = await teams.getTeamIdByDisplayName(options.teamName);
+        return groupId;
+    }
+    async getChannelId(options, teamId, logger) {
+        if (options.channelId) {
+            return options.channelId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the channel ID.`);
+        }
+        const channelId = await teams.getChannelIdByDisplayName(teamId, options.channelName);
+        return channelId;
+    }
+}
+_TeamsMessageRestoreCommand_instances = new WeakSet(), _TeamsMessageRestoreCommand_initTelemetry = function _TeamsMessageRestoreCommand_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'
+        });
+    });
+}, _TeamsMessageRestoreCommand_initOptions = function _TeamsMessageRestoreCommand_initOptions() {
+    this.options.unshift({
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
+    }, {
+        option: '--channelId [channelId]'
+    }, {
+        option: '--channelName [channelName]'
+    }, {
+        option: '-i, --id <id>'
+    });
+}, _TeamsMessageRestoreCommand_initValidators = function _TeamsMessageRestoreCommand_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;
+    });
+}, _TeamsMessageRestoreCommand_initOptionSets = function _TeamsMessageRestoreCommand_initOptionSets() {
+    this.optionSets.push({ options: ['teamId', 'teamName'] }, { options: ['channelId', 'channelName'] });
+}, _TeamsMessageRestoreCommand_initTypes = function _TeamsMessageRestoreCommand_initTypes() {
+    this.types.string.push('teamId', 'teamName', 'channelId', 'channelName', 'id');
+};
+export default new TeamsMessageRestoreCommand();
+//# sourceMappingURL=message-restore.js.map

package/dist/m365/teams/commands.js

@@ -30,13 +30,16 @@ 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_RESTORE: `${prefix} message restore`,
     MESSAGE_SEND: `${prefix} message send`,
     MESSAGINGSETTINGS_LIST: `${prefix} messagingsettings list`,
     MESSAGINGSETTINGS_SET: `${prefix} messagingsettings set`,

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

package/dist/utils/formatting.js

@@ -9,6 +9,8 @@ export var CheckStatus;
 (function (CheckStatus) {
     CheckStatus[CheckStatus["Success"] = 0] = "Success";
     CheckStatus[CheckStatus["Failure"] = 1] = "Failure";
+    CheckStatus[CheckStatus["Information"] = 2] = "Information";
+    CheckStatus[CheckStatus["Warning"] = 3] = "Warning";
 })(CheckStatus || (CheckStatus = {}));
 export const formatting = {
     escapeXml(s) {
@@ -37,6 +39,22 @@ export const formatting = {
     parseJsonWithBom(s) {
         return JSON.parse(s.replace(/^\uFEFF/, ''));
     },
+    /**
+     * Tries to parse a string as JSON. If it fails, returns the original string.
+     * @param value JSON string to parse.
+     * @returns JSON object or the original string if parsing fails.
+     */
+    tryParseJson(value) {
+        try {
+            if (typeof value !== 'string') {
+                return value;
+            }
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    },
     filterObject(obj, propertiesToInclude) {
         const objKeys = Object.keys(obj);
         return propertiesToInclude
@@ -152,7 +170,18 @@ export const formatting = {
             process.env.TERM === 'xterm-256color';
         const success = primarySupported ? '✔' : '√';
         const failure = primarySupported ? '✖' : '×';
-        return `${result === CheckStatus.Success ? chalk.green(success) : chalk.red(failure)} ${message}`;
+        const information = 'i';
+        const warning = '!';
+        switch (result) {
+            case CheckStatus.Success:
+                return `${chalk.green(success)} ${message}`;
+            case CheckStatus.Failure:
+                return `${chalk.red(failure)} ${message}`;
+            case CheckStatus.Information:
+                return `${chalk.blue(information)} ${message}`;
+            case CheckStatus.Warning:
+                return `${chalk.yellow(warning)} ${message}`;
+        }
     },
     convertArrayToHashTable(key, array) {
         const resultAsKeyValuePair = {};