@pnp/cli-microsoft365 10.0.0-beta.e925c1c → 10.0.0

package/dist/m365/teams/commands/cache/cache-remove.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 _TeamsCacheRemoveCommand_instances, _TeamsCacheRemoveCommand_initTelemetry, _TeamsCacheRemoveCommand_initOptions, _TeamsCacheRemoveCommand_initValidators;
+var _TeamsCacheRemoveCommand_instances, _a, _TeamsCacheRemoveCommand_initTelemetry, _TeamsCacheRemoveCommand_initOptions, _TeamsCacheRemoveCommand_initValidators;
 import child_process from 'child_process';
 import fs from 'fs';
 import { homedir } from 'os';
@@ -30,7 +30,7 @@ class TeamsCacheRemoveCommand extends AnonymousCommand {
     async commandAction(logger, args) {
         try {
             if (args.options.force) {
-                await this.clearTeamsCache(logger);
+                await this.clearTeamsCache(args.options.client?.toLowerCase() || 'new', logger);
             }
             else {
                 await logger.logToStderr('This command will execute the following steps.');
@@ -38,7 +38,7 @@ class TeamsCacheRemoveCommand extends AnonymousCommand {
                 await logger.logToStderr('- Clear the Microsoft Teams cached files.');
                 const result = await cli.promptForConfirmation({ message: `Are you sure you want to clear your Microsoft Teams cache?` });
                 if (result) {
-                    await this.clearTeamsCache(logger);
+                    await this.clearTeamsCache(args.options.client?.toLowerCase() || 'new', logger);
                 }
             }
         }
@@ -46,33 +46,50 @@ class TeamsCacheRemoveCommand extends AnonymousCommand {
             this.handleError(err);
         }
     }
-    async clearTeamsCache(logger) {
-        const filePath = await this.getTeamsCacheFolderPath(logger);
-        const folderExists = await this.checkIfCacheFolderExists(filePath, logger);
+    async clearTeamsCache(client, logger) {
+        const filePaths = await this.getTeamsCacheFolderPaths(client, logger);
+        let folderExists = true;
+        for (const filePath of filePaths) {
+            const exists = await this.checkIfCacheFolderExists(filePath, logger);
+            if (!exists) {
+                folderExists = false;
+            }
+        }
         if (folderExists) {
-            await this.killRunningProcess(logger);
-            await this.removeCacheFiles(filePath, logger);
+            await this.killRunningProcess(client, logger);
+            await this.removeCacheFiles(filePaths, logger);
             await logger.logToStderr('Teams cache cleared!');
         }
         else {
             await logger.logToStderr('Cache folder does not exist. Nothing to remove.');
         }
     }
-    async getTeamsCacheFolderPath(logger) {
+    async getTeamsCacheFolderPaths(client, logger) {
         const platform = process.platform;
         if (this.verbose) {
             await logger.logToStderr(`Getting path of Teams cache folder for platform ${platform}...`);
         }
-        let filePath = '';
+        const filePaths = [];
         switch (platform) {
             case 'win32':
-                filePath = `${process.env.APPDATA}\\Microsoft\\Teams`;
+                if (client === 'classic') {
+                    filePaths.push(`${process.env.APPDATA}\\Microsoft\\Teams`);
+                }
+                else {
+                    filePaths.push(`${process.env.LOCALAPPDATA}\\Packages\\MSTeams_8wekyb3d8bbwe\\LocalCache\\Microsoft\\MSTeams`);
+                }
                 break;
             case 'darwin':
-                filePath = `${homedir}/Library/Application Support/Microsoft/Teams`;
+                if (client === 'classic') {
+                    filePaths.push(`${homedir}/Library/Application Support/Microsoft/Teams`);
+                }
+                else {
+                    filePaths.push(`${homedir}/Library/Group Containers/UBF8T346G9.com.microsoft.teams`);
+                    filePaths.push(`${homedir}/Library/Containers/com.microsoft.teams2`);
+                }
                 break;
         }
-        return filePath;
+        return filePaths;
     }
     async checkIfCacheFolderExists(filePath, logger) {
         if (this.verbose) {
@@ -80,7 +97,7 @@ class TeamsCacheRemoveCommand extends AnonymousCommand {
         }
         return fs.existsSync(filePath);
     }
-    async killRunningProcess(logger) {
+    async killRunningProcess(client, logger) {
         if (this.verbose) {
             await logger.logToStderr('Stopping Teams client...');
         }
@@ -88,61 +105,83 @@ class TeamsCacheRemoveCommand extends AnonymousCommand {
         let cmd = '';
         switch (platform) {
             case 'win32':
-                cmd = 'wmic process where caption="Teams.exe" get ProcessId';
+                if (client === 'classic') {
+                    cmd = 'wmic process where caption="Teams.exe" get ProcessId';
+                }
+                else {
+                    cmd = 'wmic process where caption="ms-teams.exe" get ProcessId';
+                }
                 break;
             case 'darwin':
-                cmd = `ps ax | grep MacOS/Teams -m 1 | grep -v grep | awk '{ print $1 }'`;
+                if (client === 'classic') {
+                    cmd = `ps ax | grep MacOS/Teams -m 1 | grep -v grep | awk '{ print $1 }'`;
+                }
+                else {
+                    cmd = `ps ax | grep MacOS/MSTeams -m 1 | grep -v grep | awk '{ print $1 }'`;
+                }
                 break;
         }
         if (this.debug) {
             await logger.logToStderr(cmd);
         }
         const cmdOutput = await this.exec(cmd);
-        if (platform === 'darwin') {
+        if (platform === 'darwin' && cmdOutput.stdout) {
             process.kill(parseInt(cmdOutput.stdout));
         }
         else if (platform === 'win32') {
             const processJson = formatting.parseCsvToJson(cmdOutput.stdout);
-            processJson.filter(proc => proc.ProcessId).map((proc) => {
+            for (const proc of processJson) {
                 process.kill(proc.ProcessId);
-            });
+            }
         }
         if (this.verbose) {
             await logger.logToStderr('Teams client closed');
         }
     }
-    async removeCacheFiles(filePath, logger) {
+    async removeCacheFiles(filePaths, logger) {
         if (this.verbose) {
             await logger.logToStderr('Removing Teams cache files...');
         }
         const platform = process.platform;
-        let cmd = '';
-        switch (platform) {
-            case 'win32':
-                cmd = `rmdir /s /q "${filePath}"`;
-                break;
-            case 'darwin':
-                cmd = `rm -r "${filePath}"`;
-                break;
-        }
-        if (this.debug) {
-            await logger.logToStderr(cmd);
+        const baseCmd = platform === 'win32' ? 'rmdir /s /q ' : 'rm -r ';
+        for (const filePath of filePaths) {
+            const cmd = `${baseCmd}"${filePath}"`;
+            if (this.debug) {
+                await logger.logToStderr(cmd);
+            }
+            try {
+                await this.exec(cmd);
+            }
+            catch (err) {
+                if (err?.stderr?.includes('Operation not permitted')) {
+                    await logger.log('Deleting the folder failed. Please have a look at the following URL to delete the folders manually: https://answers.microsoft.com/en-us/msteams/forum/all/clearing-cache-on-microsoft-teams/35876f6b-eb1a-4b77-bed1-02ce3277091f');
+                }
+                else {
+                    throw err;
+                }
+            }
         }
-        await this.exec(cmd);
     }
 }
-_TeamsCacheRemoveCommand_instances = new WeakSet(), _TeamsCacheRemoveCommand_initTelemetry = function _TeamsCacheRemoveCommand_initTelemetry() {
+_a = TeamsCacheRemoveCommand, _TeamsCacheRemoveCommand_instances = new WeakSet(), _TeamsCacheRemoveCommand_initTelemetry = function _TeamsCacheRemoveCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
+            client: args.options.client,
             force: !!args.options.force
         });
     });
 }, _TeamsCacheRemoveCommand_initOptions = function _TeamsCacheRemoveCommand_initOptions() {
     this.options.unshift({
+        option: '-c, --client',
+        autocomplete: _a.allowedClients
+    }, {
         option: '-f, --force'
     });
 }, _TeamsCacheRemoveCommand_initValidators = function _TeamsCacheRemoveCommand_initValidators() {
-    this.validators.push(async () => {
+    this.validators.push(async (args) => {
+        if (args.options.client && !_a.allowedClients.includes(args.options.client.toLowerCase())) {
+            return `'${args.options.client}' is not a valid value for option 'client'. Allowed values are ${_a.allowedClients.join(', ')}`;
+        }
         if (process.env.CLIMICROSOFT365_ENV === 'docker') {
             return 'Because you\'re running CLI for Microsoft 365 in a Docker container, we can\'t clear the cache on your host. Instead run this command on your host using "npx ..."';
         }
@@ -152,5 +191,6 @@ _TeamsCacheRemoveCommand_instances = new WeakSet(), _TeamsCacheRemoveCommand_ini
         return true;
     });
 };
+TeamsCacheRemoveCommand.allowedClients = ['new', 'classic'];
 export default new TeamsCacheRemoveCommand();
 //# sourceMappingURL=cache-remove.js.map

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

@@ -5,11 +5,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _TeamsChannelGetCommand_instances, _TeamsChannelGetCommand_initTelemetry, _TeamsChannelGetCommand_initOptions, _TeamsChannelGetCommand_initValidators, _TeamsChannelGetCommand_initOptionSets;
 import request from '../../../../request.js';
-import { entraGroup } from '../../../../utils/entraGroup.js';
-import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
+import { teams } from '../../../../utils/teams.js';
 class TeamsChannelGetCommand extends GraphCommand {
     get name() {
         return commands.CHANNEL_GET;
@@ -20,63 +19,29 @@ class TeamsChannelGetCommand extends GraphCommand {
     constructor() {
         super();
         _TeamsChannelGetCommand_instances.add(this);
-        this.teamId = "";
         __classPrivateFieldGet(this, _TeamsChannelGetCommand_instances, "m", _TeamsChannelGetCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _TeamsChannelGetCommand_instances, "m", _TeamsChannelGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _TeamsChannelGetCommand_instances, "m", _TeamsChannelGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _TeamsChannelGetCommand_instances, "m", _TeamsChannelGetCommand_initOptionSets).call(this);
     }
-    async getTeamId(args) {
-        if (args.options.teamId) {
-            return args.options.teamId;
-        }
-        const group = await entraGroup.getGroupByDisplayName(args.options.teamName);
-        if (group.resourceProvisioningOptions.indexOf('Team') === -1) {
-            throw `The specified team does not exist in the Microsoft Teams`;
-        }
-        return group.id;
-    }
-    async getChannelId(args) {
-        if (args.options.id) {
-            return args.options.id;
-        }
-        if (args.options.primary) {
-            return '';
-        }
-        const channelRequestOptions = {
-            url: `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(this.teamId)}/channels?$filter=displayName eq '${formatting.encodeQueryParameter(args.options.name)}'`,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
-        const response = await request.get(channelRequestOptions);
-        const channelItem = response.value[0];
-        if (!channelItem) {
-            throw `The specified channel does not exist in the Microsoft Teams team`;
-        }
-        return channelItem.id;
-    }
     async commandAction(logger, args) {
         try {
-            this.teamId = await this.getTeamId(args);
-            const channelId = await this.getChannelId(args);
-            let url = '';
-            if (args.options.primary) {
-                url = `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(this.teamId)}/primaryChannel`;
+            const teamId = args.options.teamId || await teams.getTeamIdByDisplayName(args.options.teamName);
+            let channel;
+            if (args.options.primary || args.options.id) {
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/teams/${teamId}/${args.options.primary ? 'primaryChannel' : `channels/${args.options.id}`}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                channel = await request.get(requestOptions);
             }
             else {
-                url = `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(this.teamId)}/channels/${formatting.encodeQueryParameter(channelId)}`;
+                channel = await teams.getChannelByDisplayName(teamId, args.options.name);
             }
-            const requestOptions = {
-                url: url,
-                headers: {
-                    accept: 'application/json;odata.metadata=none'
-                },
-                responseType: 'json'
-            };
-            const res = await request.get(requestOptions);
-            await logger.log(res);
+            await logger.log(channel);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
@@ -90,7 +55,7 @@ _TeamsChannelGetCommand_instances = new WeakSet(), _TeamsChannelGetCommand_initT
             teamName: typeof args.options.teamName !== 'undefined',
             id: typeof args.options.id !== 'undefined',
             name: typeof args.options.name !== 'undefined',
-            primary: (!(!args.options.primary)).toString()
+            primary: !!args.options.primary
         });
     });
 }, _TeamsChannelGetCommand_initOptions = function _TeamsChannelGetCommand_initOptions() {

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

@@ -0,0 +1,152 @@
+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 _TeamsMeetingTranscriptGetCommand_instances, _TeamsMeetingTranscriptGetCommand_initTelemetry, _TeamsMeetingTranscriptGetCommand_initOptions, _TeamsMeetingTranscriptGetCommand_initValidators, _TeamsMeetingTranscriptGetCommand_initOptionSets;
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.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 fs from 'fs';
+import path from 'path';
+class TeamsMeetingTranscriptGetCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_TRANSCRIPT_GET;
+    }
+    get description() {
+        return 'Downloads a transcript for a given meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingTranscriptGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving transcript for the given meeting...`);
+            }
+            let requestUrl = `${this.resource}/beta/`;
+            if (isAppOnlyAccessToken) {
+                if (!args.options.userId && !args.options.userName && !args.options.email) {
+                    throw `The option 'userId', 'userName' or 'email' is required when retrieving meeting transcript using app only permissions`;
+                }
+                requestUrl += 'users/';
+                if (args.options.userId) {
+                    requestUrl += args.options.userId;
+                }
+                else if (args.options.userName) {
+                    requestUrl += args.options.userName;
+                }
+                else if (args.options.email) {
+                    if (this.verbose) {
+                        await logger.logToStderr(`Getting user ID for user with email '${args.options.email}'.`);
+                    }
+                    const userId = await entraUser.getUserIdByEmail(args.options.email);
+                    requestUrl += userId;
+                }
+            }
+            else {
+                if (args.options.userId || args.options.userName || args.options.email) {
+                    throw `The options 'userId', 'userName', and 'email' cannot be used while retrieving meeting transcript using delegated permissions`;
+                }
+                requestUrl += `me`;
+            }
+            requestUrl += `/onlineMeetings/${args.options.meetingId}/transcripts/${args.options.id}`;
+            if (args.options.outputFile) {
+                requestUrl += '/content?$format=text/vtt';
+            }
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: args.options.outputFile ? 'stream' : 'json'
+            };
+            const meetingTranscript = await request.get(requestOptions);
+            if (meetingTranscript) {
+                if (args.options.outputFile) {
+                    // Not possible to use async/await for this promise
+                    await new Promise((resolve, reject) => {
+                        const writer = fs.createWriteStream(args.options.outputFile);
+                        meetingTranscript.data.pipe(writer);
+                        writer.on('error', err => {
+                            reject(err);
+                        });
+                        writer.on('close', async () => {
+                            const filePath = args.options.outputFile;
+                            if (this.verbose) {
+                                await logger.logToStderr(`File saved to path ${filePath}`);
+                            }
+                            return resolve();
+                        });
+                    });
+                }
+                else {
+                    await logger.log(meetingTranscript);
+                }
+            }
+            else {
+                throw `The specified meeting transcript was not found`;
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_TeamsMeetingTranscriptGetCommand_instances = new WeakSet(), _TeamsMeetingTranscriptGetCommand_initTelemetry = function _TeamsMeetingTranscriptGetCommand_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',
+            outputFile: typeof args.options.outputFile !== 'undefined'
+        });
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptions = function _TeamsMeetingTranscriptGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--email [email]'
+    }, {
+        option: '-m, --meetingId <meetingId>'
+    }, {
+        option: '-i, --id <id>'
+    }, {
+        option: '-f, --outputFile [outputFile]'
+    });
+}, _TeamsMeetingTranscriptGetCommand_initValidators = function _TeamsMeetingTranscriptGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid Guid`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid user principal name (UPN)`;
+        }
+        if (args.options.email && !validation.isValidUserPrincipalName(args.options.email)) {
+            return `${args.options.email} is not a valid email`;
+        }
+        if (args.options.outputFile && !fs.existsSync(path.dirname(args.options.outputFile))) {
+            return 'Specified path where to save the file does not exits';
+        }
+        return true;
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptionSets = function _TeamsMeetingTranscriptGetCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['userId', 'userName', 'email'],
+        runsWhen: (args) => args.options.userId || args.options.userName || args.options.email
+    });
+};
+export default new TeamsMeetingTranscriptGetCommand();
+//# sourceMappingURL=meeting-transcript-get.js.map

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

@@ -29,9 +29,11 @@ class TeamsTabListCommand extends GraphCommand {
         const endpoint = `${this.resource}/v1.0/teams/${args.options.teamId}/channels/${formatting.encodeQueryParameter(args.options.channelId)}/tabs?$expand=teamsApp`;
         try {
             const items = await odata.getAllItems(endpoint);
-            items.forEach(i => {
-                i.teamsAppTabId = i.teamsApp.id;
-            });
+            if (args.options.output !== 'json') {
+                items.forEach(i => {
+                    i.teamsAppTabId = i.teamsApp.id;
+                });
+            }
             await logger.log(items);
         }
         catch (err) {

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

@@ -5,11 +5,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _TeamsTeamGetCommand_instances, _TeamsTeamGetCommand_initTelemetry, _TeamsTeamGetCommand_initOptions, _TeamsTeamGetCommand_initValidators, _TeamsTeamGetCommand_initOptionSets;
 import request from '../../../../request.js';
-import { entraGroup } from '../../../../utils/entraGroup.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
+import { teams } from '../../../../utils/teams.js';
 class TeamsTeamGetCommand extends GraphCommand {
     get name() {
         return commands.TEAM_GET;
@@ -25,28 +25,23 @@ class TeamsTeamGetCommand extends GraphCommand {
         __classPrivateFieldGet(this, _TeamsTeamGetCommand_instances, "m", _TeamsTeamGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _TeamsTeamGetCommand_instances, "m", _TeamsTeamGetCommand_initOptionSets).call(this);
     }
-    async getTeamId(args) {
-        if (args.options.id) {
-            return args.options.id;
-        }
-        const group = await entraGroup.getGroupByDisplayName(args.options.name);
-        if (group.resourceProvisioningOptions.indexOf('Team') === -1) {
-            throw 'The specified team does not exist in the Microsoft Teams';
-        }
-        return group.id;
-    }
     async commandAction(logger, args) {
         try {
-            const teamId = await this.getTeamId(args);
-            const requestOptions = {
-                url: `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(teamId)}`,
-                headers: {
-                    accept: 'application/json;odata.metadata=none'
-                },
-                responseType: 'json'
-            };
-            const res = await request.get(requestOptions);
-            await logger.log(res);
+            let team;
+            if (args.options.id) {
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(args.options.id)}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                team = await request.get(requestOptions);
+            }
+            else {
+                team = await teams.getTeamByDisplayName(args.options.name);
+            }
+            await logger.log(team);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/teams/commands.js

@@ -32,6 +32,7 @@ export default {
     MEETING_LIST: `${prefix} meeting list`,
     MEETING_ATTENDANCEREPORT_GET: `${prefix} meeting attendancereport get`,
     MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
+    MEETING_TRANSCRIPT_GET: `${prefix} meeting transcript get`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,

package/dist/m365/viva/commands/engage/Community.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Community.js.map

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

@@ -0,0 +1,28 @@
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class VivaEngageCommunityListCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_LIST;
+    }
+    get description() {
+        return 'Lists all Viva Engage communities';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'privacy'];
+    }
+    async commandAction(logger) {
+        if (this.verbose) {
+            await logger.logToStderr('Getting all Viva Engage communities...');
+        }
+        try {
+            const results = await odata.getAllItems(`${this.resource}/v1.0/employeeExperience/communities`);
+            await logger.log(results);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new VivaEngageCommunityListCommand();
+//# sourceMappingURL=engage-community-list.js.map