@pnp/cli-microsoft365 7.2.0 → 7.3.0-beta.01256d2

package/dist/m365/external/commands/item/item-add.js

@@ -0,0 +1,144 @@
+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 _ExternalItemAddCommand_instances, _a, _ExternalItemAddCommand_initTelemetry, _ExternalItemAddCommand_initOptions, _ExternalItemAddCommand_initValidators;
+import request from '../../../../request.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class ExternalItemAddCommand extends GraphCommand {
+    get name() {
+        return commands.ITEM_ADD;
+    }
+    get description() {
+        return 'Creates external item';
+    }
+    constructor() {
+        super();
+        _ExternalItemAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _ExternalItemAddCommand_instances, "m", _ExternalItemAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _ExternalItemAddCommand_instances, "m", _ExternalItemAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _ExternalItemAddCommand_instances, "m", _ExternalItemAddCommand_initValidators).call(this);
+    }
+    allowUnknownOptions() {
+        return true;
+    }
+    async commandAction(logger, args) {
+        const acls = args.options.acls
+            .split(';')
+            .map(acl => {
+            const aclParts = acl.split(',');
+            return {
+                accessType: aclParts[0],
+                type: aclParts[1],
+                value: aclParts[2]
+            };
+        });
+        const requestBody = {
+            id: args.options.id,
+            content: {
+                value: args.options.content,
+                type: args.options.contentType ?? 'text'
+            },
+            acl: acls,
+            properties: {}
+        };
+        // we need to rewrite the @odata properties to the correct format
+        // because . in @odata.type is interpreted by minimist as a child property
+        // we also need to extract multiple values for collections into arrays
+        this.rewriteCollectionProperties(args.options);
+        this.addUnknownOptionsToPayload(requestBody.properties, args.options);
+        const requestOptions = {
+            url: `${this.resource}/v1.0/external/connections/${args.options.externalConnectionId}/items/${args.options.id}`,
+            headers: {
+                accept: 'application/json;odata.metadata=none',
+                'content-type': 'application/json'
+            },
+            responseType: 'json',
+            data: requestBody
+        };
+        try {
+            const externalItem = await request.put(requestOptions);
+            if (args.options.output === 'csv' || args.options.output === 'md') {
+                // for CSV and md, we need to bring the properties to the main object
+                // and convert arrays to comma-separated strings or they will be dropped
+                // from the output
+                Object.getOwnPropertyNames(externalItem.properties).forEach(name => {
+                    if (Array.isArray(externalItem.properties[name])) {
+                        externalItem[name] = externalItem.properties[name].join(', ');
+                    }
+                    else {
+                        externalItem[name] = externalItem.properties[name];
+                    }
+                });
+            }
+            await logger.log(externalItem);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    rewriteCollectionProperties(options) {
+        Object.getOwnPropertyNames(options).forEach(name => {
+            if (!name.endsWith('@odata')) {
+                return;
+            }
+            options[`${name}.type`] = options[name].type;
+            delete options[name];
+            // convert the value of a collection to an array
+            const nameWithoutOData = name.substring(0, name.indexOf('@odata'));
+            if (options[nameWithoutOData]) {
+                options[nameWithoutOData] = options[nameWithoutOData].split(';#');
+            }
+        });
+    }
+}
+_a = ExternalItemAddCommand, _ExternalItemAddCommand_instances = new WeakSet(), _ExternalItemAddCommand_initTelemetry = function _ExternalItemAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            contentType: typeof args.options.contentType
+        });
+    });
+}, _ExternalItemAddCommand_initOptions = function _ExternalItemAddCommand_initOptions() {
+    this.options.unshift({
+        option: '--id <id>'
+    }, {
+        option: '--externalConnectionId <externalConnectionId>'
+    }, {
+        option: '--content <content>'
+    }, {
+        option: '--contentType [contentType]',
+        autocomplete: _a.contentType
+    }, {
+        option: '--acls <acls>'
+    });
+}, _ExternalItemAddCommand_initValidators = function _ExternalItemAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.contentType &&
+            _a.contentType.indexOf(args.options.contentType) < 0) {
+            return `${args.options.contentType} is not a valid value for contentType. Allowed values are ${_a.contentType.join(', ')}`;
+        }
+        // verify that each value for ACLs consists of three parts
+        // and that the values are correct
+        const acls = args.options.acls.split(';');
+        for (let i = 0; i < acls.length; i++) {
+            const acl = acls[i].split(',');
+            if (acl.length !== 3) {
+                return `The value ${acls[i]} for option acls is not in the correct format. The correct format is "accessType,type,value", eg. "grant,everyone,everyone"`;
+            }
+            const accessTypeValues = ['grant', 'deny'];
+            if (accessTypeValues.indexOf(acl[0]) < 0) {
+                return `The value ${acl[0]} for option acls is not valid. Allowed values are ${accessTypeValues.join(', ')}}`;
+            }
+            const aclTypeValues = ['user', 'group', 'everyone', 'everyoneExceptGuests', 'externalGroup'];
+            if (aclTypeValues.indexOf(acl[1]) < 0) {
+                return `The value ${acl[1]} for option acls is not valid. Allowed values are ${aclTypeValues.join(', ')}}`;
+            }
+        }
+        return true;
+    });
+};
+ExternalItemAddCommand.contentType = ['text', 'html'];
+export default new ExternalItemAddCommand();
+//# sourceMappingURL=item-add.js.map

package/dist/m365/external/commands.js

@@ -2,6 +2,7 @@ const prefix = 'external';
 const searchPrefix = 'search';
 export default {
     CONNECTION_ADD: `${prefix} connection add`,
+    CONNECTION_DOCTOR: `${prefix} connection doctor`,
     CONNECTION_GET: `${prefix} connection get`,
     CONNECTION_LIST: `${prefix} connection list`,
     CONNECTION_REMOVE: `${prefix} connection remove`,
@@ -10,6 +11,7 @@ export default {
     EXTERNALCONNECTION_GET: `${searchPrefix} externalconnection get`,
     EXTERNALCONNECTION_LIST: `${searchPrefix} externalconnection list`,
     EXTERNALCONNECTION_REMOVE: `${searchPrefix} externalconnection remove`,
-    EXTERNALCONNECTION_SCHEMA_ADD: `${searchPrefix} externalconnection schema add`
+    EXTERNALCONNECTION_SCHEMA_ADD: `${searchPrefix} externalconnection schema add`,
+    ITEM_ADD: `${prefix} item add`
 };
 //# sourceMappingURL=commands.js.map

package/dist/m365/teams/commands/meeting/meeting-add.js

@@ -0,0 +1,151 @@
+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 _TeamsMeetingAddCommand_instances, _TeamsMeetingAddCommand_initTelemetry, _TeamsMeetingAddCommand_initOptions, _TeamsMeetingAddCommand_initValidators;
+import auth from '../../../../Auth.js';
+import { aadUser } from '../../../../utils/aadUser.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 request from '../../../../request.js';
+class TeamsMeetingAddCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_ADD;
+    }
+    get description() {
+        return 'Creates a new online meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAddCommand_instances, "m", _TeamsMeetingAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAddCommand_instances, "m", _TeamsMeetingAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAddCommand_instances, "m", _TeamsMeetingAddCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.service.accessTokens[this.resource].accessToken);
+            if (isAppOnlyAccessToken && !args.options.organizerEmail) {
+                throw `The option 'organizerEmail' is required when creating a meeting using app only permissions`;
+            }
+            if (!isAppOnlyAccessToken && args.options.organizerEmail) {
+                throw `The option 'organizerEmail' is not supported when creating a meeting using delegated permissions`;
+            }
+            const meeting = await this.createMeeting(logger, args.options);
+            await logger.log(meeting);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    /**
+     * Creates a new online meeting
+     * @param logger
+     * @param options
+     * @returns MS Graph online meeting response
+     */
+    async createMeeting(logger, options) {
+        let requestUrl = `${this.resource}/v1.0/me`;
+        if (options.organizerEmail) {
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving Organizer Id...`);
+            }
+            const organizerId = await aadUser.getUserIdByEmail(options.organizerEmail);
+            requestUrl = `${this.resource}/v1.0/users/${organizerId}`;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Creating the meeting...`);
+        }
+        const requestData = {};
+        if (options.participantUserNames) {
+            const attendees = options.participantUserNames.trim().toLowerCase().split(',').map(p => ({
+                upn: p.trim()
+            }));
+            requestData.participants = { attendees };
+        }
+        if (options.startTime) {
+            requestData.startDateTime = options.startTime;
+        }
+        if (options.endTime) {
+            requestData.endDateTime = options.endTime;
+            if (!options.startTime) {
+                requestData.startDateTime = new Date().toISOString();
+            }
+        }
+        if (options.subject) {
+            requestData.subject = options.subject;
+        }
+        if (options.recordAutomatically !== undefined) {
+            requestData.recordAutomatically = true;
+        }
+        const requestOptions = {
+            headers: {
+                accept: 'application/json;odata.metadata=none',
+                'content-type': 'application/json'
+            },
+            responseType: 'json',
+            url: `${requestUrl}/onlineMeetings`,
+            data: requestData
+        };
+        return request.post(requestOptions);
+    }
+}
+_TeamsMeetingAddCommand_instances = new WeakSet(), _TeamsMeetingAddCommand_initTelemetry = function _TeamsMeetingAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            startTime: typeof args.options.startTime !== 'undefined',
+            endTime: typeof args.options.endTime !== 'undefined',
+            subject: typeof args.options.subject !== 'undefined',
+            participantUserNames: typeof args.options.participantUserNames !== 'undefined',
+            organizerEmail: typeof args.options.organizerEmail !== 'undefined',
+            recordAutomatically: !!args.options.recordAutomatically
+        });
+    });
+}, _TeamsMeetingAddCommand_initOptions = function _TeamsMeetingAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-s, --startTime [startTime]'
+    }, {
+        option: '-e, --endTime [endTime]'
+    }, {
+        option: '--subject [subject]'
+    }, {
+        option: '-p, --participantUserNames [participantUserNames]'
+    }, {
+        option: '--organizerEmail [organizerEmail]'
+    }, {
+        option: '-r, --recordAutomatically'
+    });
+}, _TeamsMeetingAddCommand_initValidators = function _TeamsMeetingAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.startTime && !validation.isValidISODateTime(args.options.startTime)) {
+            return `'${args.options.startTime}' is not a valid ISO date string for startTime.`;
+        }
+        if (args.options.endTime && !validation.isValidISODateTime(args.options.endTime)) {
+            return `'${args.options.endTime}' is not a valid ISO date string for endTime.`;
+        }
+        if (args.options.startTime && args.options.endTime && new Date(args.options.startTime) >= new Date(args.options.endTime)) {
+            return 'The startTime value must be before endTime.';
+        }
+        if (args.options.startTime && new Date() >= new Date(args.options.startTime)) {
+            return 'The startTime value must be in the future.';
+        }
+        if (args.options.endTime && new Date() >= new Date(args.options.endTime)) {
+            return 'The endTime value must be in the future.';
+        }
+        if (args.options.participantUserNames) {
+            const participants = args.options.participantUserNames.trim().toLowerCase().split(',').filter(e => e && e !== '');
+            if (!participants || participants.length === 0 || participants.some(e => !validation.isValidUserPrincipalName(e))) {
+                return `'${args.options.participantUserNames}' contains one or more invalid UPN.`;
+            }
+        }
+        if (args.options.organizerEmail && !validation.isValidUserPrincipalName(args.options.organizerEmail)) {
+            return `'${args.options.organizerEmail}' is not a valid email for organizerEmail.`;
+        }
+        return true;
+    });
+};
+export default new TeamsMeetingAddCommand();
+//# sourceMappingURL=meeting-add.js.map

package/dist/m365/teams/commands/user/user-app-remove.js

@@ -27,11 +27,15 @@ class TeamsUserAppRemoveCommand extends GraphCommand {
     }
     async commandAction(logger, args) {
         const removeApp = async () => {
+            const appId = await this.getAppId(args);
             // validation ensures that here we have either userId or userName
             const userId = (args.options.userId ?? args.options.userName);
             const endpoint = `${this.resource}/v1.0`;
+            if (this.verbose) {
+                await logger.logToStderr(`Removing app with ID ${args.options.id} for user ${args.options.userId}`);
+            }
             const requestOptions = {
-                url: `${endpoint}/users/${formatting.encodeQueryParameter(userId)}/teamwork/installedApps/${args.options.id}`,
+                url: `${endpoint}/users/${formatting.encodeQueryParameter(userId)}/teamwork/installedApps/${appId}`,
                 headers: {
                     'accept': 'application/json;odata.metadata=none'
                 },
@@ -54,10 +58,34 @@ class TeamsUserAppRemoveCommand extends GraphCommand {
             }
         }
     }
+    async getAppId(args) {
+        if (args.options.id) {
+            return args.options.id;
+        }
+        const requestOptions = {
+            url: `${this.resource}/v1.0/users/${args.options.userId}/teamwork/installedApps?$expand=teamsAppDefinition&$filter=teamsAppDefinition/displayName eq '${formatting.encodeQueryParameter(args.options.name)}'`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const response = await request.get(requestOptions);
+        if (response.value.length === 1) {
+            return response.value[0].id;
+        }
+        if (response.value.length === 0) {
+            throw `The specified Teams app does not exist`;
+        }
+        const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', response.value);
+        const result = (await Cli.handleMultipleResultsFound(`Multiple Teams apps with name '${args.options.name}' found.`, resultAsKeyValuePair));
+        return result.id;
+    }
 }
 _TeamsUserAppRemoveCommand_instances = new WeakSet(), _TeamsUserAppRemoveCommand_initTelemetry = function _TeamsUserAppRemoveCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
+            id: typeof args.options.id !== 'undefined',
+            name: typeof args.options.name !== 'undefined',
             userId: typeof args.options.userId !== 'undefined',
             userName: typeof args.options.userName !== 'undefined',
             force: (!!args.options.force).toString()
@@ -65,7 +93,9 @@ _TeamsUserAppRemoveCommand_instances = new WeakSet(), _TeamsUserAppRemoveCommand
     });
 }, _TeamsUserAppRemoveCommand_initOptions = function _TeamsUserAppRemoveCommand_initOptions() {
     this.options.unshift({
-        option: '--id <id>'
+        option: '--id [id]'
+    }, {
+        option: '--name [name]'
     }, {
         option: '--userId [userId]'
     }, {
@@ -84,6 +114,7 @@ _TeamsUserAppRemoveCommand_instances = new WeakSet(), _TeamsUserAppRemoveCommand
         return true;
     });
 }, _TeamsUserAppRemoveCommand_initOptionSets = function _TeamsUserAppRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['id', 'name'] });
     this.optionSets.push({ options: ['userId', 'userName'] });
 };
 export default new TeamsUserAppRemoveCommand();

package/dist/m365/teams/commands.js

@@ -27,9 +27,10 @@ export default {
     FUNSETTINGS_SET: `${prefix} funsettings set`,
     GUESTSETTINGS_LIST: `${prefix} guestsettings list`,
     GUESTSETTINGS_SET: `${prefix} guestsettings set`,
-    MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
+    MEETING_ADD: `${prefix} meeting add`,
     MEETING_GET: `${prefix} meeting get`,
     MEETING_LIST: `${prefix} meeting list`,
+    MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,

package/dist/telemetry.js

@@ -29,14 +29,6 @@ export const telemetry = {
             commandName,
             properties
         });
-    },
-    trackException: (exception) => {
-        if (Cli.getInstance().getSettingWithDefaultValue(settingsNames.disableTelemetry, false)) {
-            return;
-        }
-        trackTelemetry({
-            exception
-        });
     }
 };
 //# sourceMappingURL=telemetry.js.map

package/dist/utils/validation.js

@@ -7,8 +7,11 @@ export const validation = {
             return false;
         }
         const guidRegEx = new RegExp(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
-        // verify if the guid is a valid guid. @meid will be replaced in a later stage with the actual user id of the logged in user
-        return guidRegEx.test(guid) || guid.toLowerCase().trim() === '@meid';
+        // verify if the guid is a valid guid. @meid will be replaced in a later
+        // stage with the actual user id of the logged in user
+        // we also need to make it toString in case the args is resolved as number
+        // or boolean
+        return guidRegEx.test(guid) || guid.toString().toLowerCase().trim() === '@meid';
     },
     isValidTeamsChannelId(guid) {
         const guidRegEx = new RegExp(/^19:[0-9a-zA-Z-_]+@thread\.(skype|tacv2)$/i);

package/docs/docs/cmd/aad/group/group-list.mdx

@@ -14,6 +14,11 @@ m365 aad group list [options]
 
 ## Options
 
+```md definition-list
+`--type [type]`
+: Filter the results to only groups of a given type. Allowed values: `microsoft365`, `security`, `distribution`, `mailEnabledSecurity`. By default, all groups are listed.
+```
+
 <Global />
 
 ## Examples
@@ -24,6 +29,12 @@ Lists all groups defined in Azure Active Directory.
 m365 aad group list
 ```
 
+List all security groups defined in Azure Active Directory.
+
+```sh
+m365 aad group list --type security
+```
+
 ## Response
 
 <Tabs>

package/docs/docs/cmd/external/connection/connection-doctor.mdx

@@ -0,0 +1,179 @@
+import Global from '/docs/cmd/_global.mdx';
+
+# external connection doctor
+
+Checks if the external connection is correctly configured for use with a specified user experience in Microsoft 365
+
+## Usage
+
+```sh
+m365 external connection doctor [options]
+```
+
+## Options
+
+```md definition-list
+`-i, --id <id>`
+: The ID of the external connection to check.
+
+`--ux [ux]`
+: Microsoft 365 experience for which to check compatibility. Allowed values `copilot`, `search`, `all` (default)
+
+<Global />
+
+## Remarks
+
+The `external connection doctor` command runs several automated checks to verify if an external connection is correctly configured for use with a user experience in Microsoft 365.
+
+Check|ID|UX|Type|Description
+-----|--|:--:|--|------------
+Required semantic labels|`copilotRequiredSemanticLabels`|Copilot|Required|Checks if the external connection schema has the required semantic labels configured: `title`, `url` and `iconUrl`
+Searchable properties|Copilot|`searchableProperties`|Required|Checks if the external connection schema has at least one searchable property
+Items have content ingested|`contentIngested`|Copilot|Required|Checks if external items have content ingested
+Connection configured for inline results|`enabledForInlineResults`|Copilot|Required (manual)|Check if the external connection is configured for inline results
+Items have activities recorded|`itemsHaveActivities`|Copilot|Recommended (manual)|Check if external items have activities recorded
+Meaningful connection name and description|`meaningfulNameAndDescription`|Copilot|Required (manual)|Check if the external connection has a meaningful name and description
+Semantic labels|`semanticLabels`|Search|Recommended|Checks if the external connection schema uses semantic labels
+Searchable properties|`searchableProperties`|Search|Recommended|Checks if the external connection schema has at least one searchable property
+Result types|`resultType`|Search|Recommended|Checks if the external connection has a result type configured
+Items have content ingested|`contentIngested`|Search|Recommended|Checks if external items have content ingested
+Items have activities recorded|`itemsHaveActivities`|Search|Recommended|Check if external items have activities recorded
+urlToItemResolver configured|`urlToItemResolver`|All|Recommended|Checks if the external connection has at least one urlToItemResolver configured
+
+Required checks must pass for the external connection to be compatible with the specified user experience. Recommended checks are optional, but recommended for optimal user experience.
+
+Some checks must be done manually, because there are no APIs available to verify the configuration automatically.
+
+When you check the compatibility with all UXs, and there are multiple checks with the same ID, the command will use the first matching check, following the order listed above.
+
+## Examples
+
+Checks if the external connection with the specified ID is correctly configured for use with Copilot for Microsoft 365.
+
+```sh
+m365 external connection doctor --id contosoproducts --ux copilot
+```
+
+## Response
+
+<Tabs>
+  <TabItem value="JSON">
+
+  ```json
+  [
+    {
+      "id": "loadExternalConnection",
+      "text": "Load connection",
+      "type": "required",
+      "status": "passed"
+    },
+    {
+      "id": "loadSchema",
+      "text": "Load schema",
+      "type": "required",
+      "status": "passed"
+    },
+    {
+      "id": "copilotRequiredSemanticLabels",
+      "text": "Required semantic labels",
+      "type": "required",
+      "errorMessage": "Missing label iconUrl",
+      "status": "failed"
+    },
+    {
+      "id": "searchableProperties",
+      "text": "Searchable properties",
+      "type": "required",
+      "status": "passed"
+    },
+    {
+      "id": "contentIngested",
+      "text": "Items have content ingested",
+      "type": "required",
+      "status": "passed"
+    },
+    {
+      "id": "enabledForInlineResults",
+      "text": "Connection configured for inline results",
+      "type": "required",
+      "status": "manual"
+    },
+    {
+      "id": "itemsHaveActivities",
+      "text": "Items have activities recorded",
+      "type": "recommended",
+      "status": "manual"
+    },
+    {
+      "id": "meaningfulNameAndDescription",
+      "text": "Meaningful connection name and description",
+      "type": "required",
+      "status": "manual"
+    },
+    {
+      "id": "urlToItemResolver",
+      "text": "urlToItemResolver configured",
+      "type": "recommended",
+      "status": "passed"
+    }
+  ]
+  ```
+
+  </TabItem>
+  <TabItem value="Text">
+
+  ```text
+  ✔ Load connection
+  ✔ Load schema
+  ✖ Required semantic labels: Missing label iconUrl
+  ✔ Searchable properties
+  ✔ Items have content ingested
+  ℹ Connection configured for inline results (manual)
+  ℹ Items have activities recorded (manual)
+  ℹ Meaningful connection name and description (manual)
+  ✔ urlToItemResolver configured
+  ```
+
+  </TabItem>
+  <TabItem value="CSV">
+
+  ```csv
+  id,text,type,status,errorMessage
+  loadExternalConnection,Load connection,required,passed,
+  loadSchema,Load schema,required,passed,
+  copilotRequiredSemanticLabels,Required semantic labels,required,failed,Missing label iconUrl
+  searchableProperties,Searchable properties,required,passed,
+  contentIngested,Items have content ingested,required,passed,
+  enabledForInlineResults,Connection configured for inline results,required,manual,
+  itemsHaveActivities,Items have activities recorded,recommended,manual,
+  meaningfulNameAndDescription,Meaningful connection name and description,required,manual,
+  urlToItemResolver,urlToItemResolver configured,recommended,passed,
+  ```
+
+  </TabItem>
+  <TabItem value="Markdown">
+
+  ```md
+  # external connection doctor --id "msgraphdocs" --ux "copilot"
+
+  Date: 11/23/2023
+
+  Check|Type|Status|Error message
+  :----|:--:|:----:|:------------
+  Load connection|required|passed|
+  Load schema|required|passed|
+  Required semantic labels|required|failed|Missing label iconUrl
+  Searchable properties|required|passed|
+  Items have content ingested|required|passed|
+  Connection configured for inline results|required|manual|
+  Items have activities recorded|recommended|manual|
+  Meaningful connection name and description|required|manual|
+  urlToItemResolver configured|recommended|passed|
+  ```
+
+  </TabItem>
+</Tabs>
+
+## More information
+
+- Microsoft Graph connector experiences: [https://learn.microsoft.com/graph/connecting-external-content-experiences](https://learn.microsoft.com/graph/connecting-external-content-experiences)