@pnp/cli-microsoft365 12.0.0-beta.d654135 → 12.0.0-beta.f682e10

package/dist/googleAnalytics.js

@@ -0,0 +1,96 @@
+import Axios from 'axios';
+import Configstore from 'configstore';
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import url from 'url';
+import config from './config.js';
+import { app } from './utils/app.js';
+const measurementId = 'G-4BNT8MQCYT';
+const apiSecret = 'mm_3WD_TRuO-9MKsuZnhDQ';
+const endpoint = 'https://www.google-analytics.com/mp/collect';
+const clientIdSetting = 'telemetryClientId';
+const requestTimeout = 3000;
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+const commonProperties = {
+    version: `${app.packageJson().version}${fs.existsSync(path.join(__dirname, `..${path.sep}src`)) ? '-dev' : ''}`,
+    node: process.version,
+    os: os.platform(),
+    env: process.env.CLIMICROSOFT365_ENV ?? '',
+    ci: Boolean(process.env.CI).toString()
+};
+function getClientId() {
+    const store = new Configstore(config.configstoreName);
+    let clientId = store.get(clientIdSetting);
+    if (!clientId) {
+        clientId = crypto.randomUUID();
+        store.set(clientIdSetting, clientId);
+    }
+    return clientId;
+}
+function getSessionId(sessionId) {
+    return parseInt(crypto.createHash('sha256').update(sessionId).digest('hex').substring(0, 12), 16);
+}
+function toEventValue(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function getEvents(commandName, properties, context) {
+    const sessionId = getSessionId(context.sessionId);
+    const eventProperties = Object.entries(properties).reduce((result, [name, value]) => {
+        if (typeof value !== 'undefined') {
+            result[name] = toEventValue(value);
+        }
+        return result;
+    }, {});
+    return [{
+            name: 'command_used',
+            params: {
+                ['command_name']: commandName,
+                ...commonProperties,
+                shell: context.shell,
+                ...eventProperties,
+                ['session_id']: sessionId,
+                ['engagement_time_msec']: 1
+            }
+        }];
+}
+async function sendEvents(events) {
+    const clientId = getClientId();
+    const response = await Axios.post(`${endpoint}?measurement_id=${measurementId}&api_secret=${apiSecret}`, {
+        ['client_id']: clientId,
+        events
+    }, {
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        timeout: requestTimeout,
+        validateStatus: () => true
+    });
+    if (response.status < 200 || response.status >= 300) {
+        throw new Error(`Google Analytics returned ${response.status}`);
+    }
+}
+export const googleAnalytics = {
+    commonProperties,
+    trackEvent: async (commandName, properties, context) => {
+        await sendEvents(getEvents(commandName, properties, context));
+    },
+    trackException: async (exception, context) => {
+        const description = exception instanceof Error ? exception.message : String(exception);
+        await sendEvents([{
+                name: 'exception',
+                params: {
+                    description: description.substring(0, 100),
+                    ...commonProperties,
+                    shell: context.shell,
+                    ['session_id']: getSessionId(context.sessionId),
+                    ['engagement_time_msec']: 1
+                }
+            }]);
+    }
+};
+//# sourceMappingURL=googleAnalytics.js.map

package/dist/m365/spo/commands/file/file-get.js

@@ -64,9 +64,10 @@ class SpoFileGetCommand extends SpoCommand {
             headers: {
                 'accept': 'application/json;odata=nometadata'
             },
-            // Set responseType to arraybuffer, otherwise binary data will be encoded
-            // to utf8 and binary data is corrupt
-            responseType: args.options.asFile ? 'stream' : 'json'
+            // Use stream for --asFile, so binary data is piped to disk as-is and
+            // isn't encoded to utf8 (which would corrupt it). Use text for
+            // --asString. Use json for all other cases.
+            responseType: args.options.asFile ? 'stream' : args.options.asString ? 'text' : 'json'
         };
         try {
             const file = await request.get(requestOptions);

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

@@ -0,0 +1,90 @@
+import commands from '../../commands.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+import { validation } from '../../../../utils/validation.js';
+import { cli } from '../../../../cli/cli.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    webUrl: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    })
+        .alias('u'),
+    url: z.string().optional(),
+    id: z.uuid().optional().alias('i'),
+    force: z.boolean().optional().alias('f')
+});
+class SpoFolderUnarchiveCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_UNARCHIVE;
+    }
+    get description() {
+        return 'Unarchives a folder';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => [options.url, options.id].filter(o => o !== undefined).length === 1, {
+            error: `Specify 'url' or 'id', but not both.`
+        });
+    }
+    getExcludedOptionsWithUrls() {
+        return ['url'];
+    }
+    async commandAction(logger, args) {
+        const { webUrl, url, id, force } = args.options;
+        const identifier = url || id;
+        if (!force) {
+            const result = await cli.promptForConfirmation({ message: `Reactivation could take up to 24 hours. Folders that are reactivated cannot be archived again for a period of time. Are you sure you would like to unarchive this folder?` });
+            if (!result) {
+                return;
+            }
+        }
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Unarchiving folder ${identifier} at site ${webUrl}...`);
+            }
+            let requestUrl = `${webUrl}/_api/web`;
+            if (id) {
+                requestUrl += `/GetFolderById('${formatting.encodeQueryParameter(id)}')`;
+            }
+            else if (url) {
+                const serverRelativePath = urlUtil.getServerRelativePath(webUrl, url);
+                requestUrl += `/GetFolderByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(serverRelativePath)}')`;
+            }
+            requestUrl += '?$select=Exists,ListItemAllFields/Id,ListItemAllFields/ParentList/Id&$expand=ListItemAllFields,ListItemAllFields/ParentList';
+            const folderInfo = await request.get({
+                url: requestUrl,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            });
+            if (!folderInfo.Exists) {
+                throw `The folder '${identifier}' does not exist.`;
+            }
+            if (!folderInfo.ListItemAllFields?.ParentList) {
+                throw `The folder '${identifier}' is the root folder of a document library and cannot be unarchived. Unarchive a subfolder instead.`;
+            }
+            const requestOptions = {
+                url: `${webUrl}/_api/Lists(guid'${folderInfo.ListItemAllFields.ParentList.Id}')/items(${folderInfo.ListItemAllFields.Id})/UnArchive`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            await request.post(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new SpoFolderUnarchiveCommand();
+//# sourceMappingURL=folder-unarchive.js.map

package/dist/m365/spo/commands/listitem/listitem-get.js

@@ -11,9 +11,6 @@ import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
 class SpoListItemGetCommand extends SpoCommand {
-    allowUnknownOptions() {
-        return true;
-    }
     get name() {
         return commands.LISTITEM_GET;
     }
@@ -30,12 +27,6 @@ class SpoListItemGetCommand extends SpoCommand {
         __classPrivateFieldGet(this, _SpoListItemGetCommand_instances, "m", _SpoListItemGetCommand_initOptionSets).call(this);
     }
     async commandAction(logger, args) {
-        if (args.options.properties) {
-            await this.warn(logger, `Option 'properties' is deprecated. Please use 'fields' instead.`);
-            if (!args.options.fields) {
-                args.options.fields = args.options.properties;
-            }
-        }
         let requestUrl = `${args.options.webUrl}/_api/web`;
         if (args.options.listId) {
             requestUrl += `/lists(guid'${formatting.encodeQueryParameter(args.options.listId)}')`;
@@ -109,8 +100,6 @@ _SpoListItemGetCommand_instances = new WeakSet(), _SpoListItemGetCommand_initTel
         option: '--listUrl [listUrl]'
     }, {
         option: '--fields [fields]'
-    }, {
-        option: '-p, --properties [properties]'
     }, {
         option: '--withPermissions'
     });
@@ -135,7 +124,7 @@ _SpoListItemGetCommand_instances = new WeakSet(), _SpoListItemGetCommand_initTel
         return true;
     });
 }, _SpoListItemGetCommand_initTypes = function _SpoListItemGetCommand_initTypes() {
-    this.types.string.push('webUrl', 'listId', 'listTitle', 'id', 'uniqueId', 'fields', 'properties');
+    this.types.string.push('webUrl', 'listId', 'listTitle', 'id', 'uniqueId', 'fields');
 }, _SpoListItemGetCommand_initOptionSets = function _SpoListItemGetCommand_initOptionSets() {
     this.optionSets.push({ options: ['listId', 'listTitle', 'listUrl'] }, { options: ['id', 'uniqueId'] });
 };

package/dist/m365/spo/commands.js

@@ -72,6 +72,7 @@ export default {
     FILE_MOVE: `${prefix} file move`,
     FILE_REMOVE: `${prefix} file remove`,
     FILE_RENAME: `${prefix} file rename`,
+    FILE_UNARCHIVE: `${prefix} file unarchive`,
     FILE_RETENTIONLABEL_ENSURE: `${prefix} file retentionlabel ensure`,
     FILE_RETENTIONLABEL_REMOVE: `${prefix} file retentionlabel remove`,
     FILE_ROLEASSIGNMENT_ADD: `${prefix} file roleassignment add`,
@@ -85,7 +86,6 @@ export default {
     FILE_SHARINGLINK_LIST: `${prefix} file sharinglink list`,
     FILE_SHARINGLINK_REMOVE: `${prefix} file sharinglink remove`,
     FILE_SHARINGLINK_SET: `${prefix} file sharinglink set`,
-    FILE_UNARCHIVE: `${prefix} file unarchive`,
     FILE_VERSION_CLEAR: `${prefix} file version clear`,
     FILE_VERSION_GET: `${prefix} file version get`,
     FILE_VERSION_KEEP: `${prefix} file version keep`,
@@ -112,6 +112,7 @@ export default {
     FOLDER_SHARINGLINK_LIST: `${prefix} folder sharinglink list`,
     FOLDER_SHARINGLINK_REMOVE: `${prefix} folder sharinglink remove`,
     FOLDER_SHARINGLINK_SET: `${prefix} folder sharinglink set`,
+    FOLDER_UNARCHIVE: `${prefix} folder unarchive`,
     GET: `${prefix} get`,
     GROUP_ADD: `${prefix} group add`,
     GROUP_GET: `${prefix} group get`,

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

@@ -1,14 +1,30 @@
-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 _TeamsChannelAddCommand_instances, _TeamsChannelAddCommand_initTelemetry, _TeamsChannelAddCommand_initOptions, _TeamsChannelAddCommand_initValidators, _TeamsChannelAddCommand_initOptionSets;
 import request from '../../../../request.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from "../../../base/GraphCommand.js";
 import commands from '../../commands.js';
 import { teams } from '../../../../utils/teams.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    teamId: z.string()
+        .refine(val => validation.isValidGuid(val), {
+        message: 'The value must be a valid GUID.'
+    })
+        .optional()
+        .alias('i'),
+    teamName: z.string()
+        .optional(),
+    name: z.string()
+        .alias('n'),
+    description: z.string()
+        .optional()
+        .alias('d'),
+    type: z.enum(['standard', 'private', 'shared'])
+        .optional(),
+    owner: z.string()
+        .optional()
+});
 class TeamsChannelAddCommand extends GraphCommand {
     get name() {
         return commands.CHANNEL_ADD;
@@ -16,13 +32,30 @@ class TeamsChannelAddCommand extends GraphCommand {
     get description() {
         return 'Adds a channel to the specified Microsoft Teams team';
     }
-    constructor() {
-        super();
-        _TeamsChannelAddCommand_instances.add(this);
-        __classPrivateFieldGet(this, _TeamsChannelAddCommand_instances, "m", _TeamsChannelAddCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelAddCommand_instances, "m", _TeamsChannelAddCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelAddCommand_instances, "m", _TeamsChannelAddCommand_initValidators).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelAddCommand_instances, "m", _TeamsChannelAddCommand_initOptionSets).call(this);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(opts => [opts.teamId, opts.teamName].filter(x => x !== undefined).length === 1, {
+            message: 'Specify either teamId or teamName, but not both.',
+            params: {
+                customCode: 'optionSet',
+                options: ['teamId', 'teamName']
+            }
+        })
+            .refine(opts => !((opts.type === 'private' || opts.type === 'shared') && !opts.owner), {
+            message: 'Specify owner when creating a private or shared channel.',
+            params: {
+                customCode: 'required'
+            }
+        })
+            .refine(opts => !((opts.type !== 'private' && opts.type !== 'shared') && opts.owner), {
+            message: 'Specify owner only when creating a private or shared channel.',
+            params: {
+                customCode: 'required'
+            }
+        });
     }
     async commandAction(logger, args) {
         try {
@@ -66,49 +99,5 @@ class TeamsChannelAddCommand extends GraphCommand {
         return request.post(requestOptions);
     }
 }
-_TeamsChannelAddCommand_instances = new WeakSet(), _TeamsChannelAddCommand_initTelemetry = function _TeamsChannelAddCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            description: typeof args.options.description !== 'undefined',
-            teamId: typeof args.options.teamId !== 'undefined',
-            teamName: typeof args.options.teamName !== 'undefined',
-            type: args.options.type || 'standard',
-            owner: typeof args.options.owner !== 'undefined'
-        });
-    });
-}, _TeamsChannelAddCommand_initOptions = function _TeamsChannelAddCommand_initOptions() {
-    this.options.unshift({
-        option: '-i, --teamId [teamId]'
-    }, {
-        option: '--teamName [teamName]'
-    }, {
-        option: '-n, --name <name>'
-    }, {
-        option: '-d, --description [description]'
-    }, {
-        option: '--type [type]',
-        autocomplete: ['standard', 'private', 'shared']
-    }, {
-        option: '--owner [owner]'
-    });
-}, _TeamsChannelAddCommand_initValidators = function _TeamsChannelAddCommand_initValidators() {
-    this.validators.push(async (args) => {
-        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
-            return `${args.options.teamId} is not a valid GUID`;
-        }
-        if (args.options.type && ['standard', 'private', 'shared'].indexOf(args.options.type) === -1) {
-            return `${args.options.type} is not a valid type value. Allowed values standard|private|shared.`;
-        }
-        if ((args.options.type === 'private' || args.options.type === 'shared') && !args.options.owner) {
-            return `Specify owner when creating a ${args.options.type} channel.`;
-        }
-        if ((args.options.type !== 'private' && args.options.type !== 'shared') && args.options.owner) {
-            return `Specify owner only when creating a private or shared channel.`;
-        }
-        return true;
-    });
-}, _TeamsChannelAddCommand_initOptionSets = function _TeamsChannelAddCommand_initOptionSets() {
-    this.optionSets.push({ options: ['teamId', 'teamName'] });
-};
 export default new TeamsChannelAddCommand();
 //# sourceMappingURL=channel-add.js.map

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

@@ -1,14 +1,30 @@
-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 _TeamsChannelGetCommand_instances, _TeamsChannelGetCommand_initTelemetry, _TeamsChannelGetCommand_initOptions, _TeamsChannelGetCommand_initValidators, _TeamsChannelGetCommand_initOptionSets;
 import request from '../../../../request.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { teams } from '../../../../utils/teams.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    teamId: z.string()
+        .refine(val => validation.isValidGuid(val), {
+        message: 'The value must be a valid GUID.'
+    })
+        .optional(),
+    teamName: z.string()
+        .optional(),
+    id: z.string()
+        .refine(val => validation.isValidTeamsChannelId(val), {
+        message: 'The value is not a valid Teams channel id.'
+    })
+        .optional()
+        .alias('i'),
+    name: z.string()
+        .optional(),
+    primary: z.boolean()
+        .optional()
+});
 class TeamsChannelGetCommand extends GraphCommand {
     get name() {
         return commands.CHANNEL_GET;
@@ -16,13 +32,25 @@ class TeamsChannelGetCommand extends GraphCommand {
     get description() {
         return 'Gets information about the specific Microsoft Teams team channel';
     }
-    constructor() {
-        super();
-        _TeamsChannelGetCommand_instances.add(this);
-        __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);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(opts => [opts.teamId, opts.teamName].filter(x => x !== undefined).length === 1, {
+            message: 'Specify either teamId or teamName, but not both.',
+            params: {
+                customCode: 'optionSet',
+                options: ['teamId', 'teamName']
+            }
+        })
+            .refine(opts => [opts.id, opts.name, opts.primary].filter(x => x !== undefined).length === 1, {
+            message: 'Specify either id, name, or primary, but not both.',
+            params: {
+                customCode: 'optionSet',
+                options: ['id', 'name', 'primary']
+            }
+        });
     }
     async commandAction(logger, args) {
         try {
@@ -48,40 +76,5 @@ class TeamsChannelGetCommand extends GraphCommand {
         }
     }
 }
-_TeamsChannelGetCommand_instances = new WeakSet(), _TeamsChannelGetCommand_initTelemetry = function _TeamsChannelGetCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            teamId: typeof args.options.teamId !== 'undefined',
-            teamName: typeof args.options.teamName !== 'undefined',
-            id: typeof args.options.id !== 'undefined',
-            name: typeof args.options.name !== 'undefined',
-            primary: !!args.options.primary
-        });
-    });
-}, _TeamsChannelGetCommand_initOptions = function _TeamsChannelGetCommand_initOptions() {
-    this.options.unshift({
-        option: '--teamId [teamId]'
-    }, {
-        option: '--teamName [teamName]'
-    }, {
-        option: '-i, --id [id]'
-    }, {
-        option: '--name [name]'
-    }, {
-        option: '--primary'
-    });
-}, _TeamsChannelGetCommand_initValidators = function _TeamsChannelGetCommand_initValidators() {
-    this.validators.push(async (args) => {
-        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
-            return `${args.options.teamId} is not a valid GUID`;
-        }
-        if (args.options.id && !validation.isValidTeamsChannelId(args.options.id)) {
-            return `${args.options.id} is not a valid Teams channel id`;
-        }
-        return true;
-    });
-}, _TeamsChannelGetCommand_initOptionSets = function _TeamsChannelGetCommand_initOptionSets() {
-    this.optionSets.push({ options: ['teamId', 'teamName'] }, { options: ['id', 'name', 'primary'] });
-};
 export default new TeamsChannelGetCommand();
 //# sourceMappingURL=channel-get.js.map

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

@@ -1,14 +1,24 @@
-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 _TeamsChannelListCommand_instances, _TeamsChannelListCommand_initTelemetry, _TeamsChannelListCommand_initOptions, _TeamsChannelListCommand_initValidators, _TeamsChannelListCommand_initOptionSets;
 import { odata } from '../../../../utils/odata.js';
 import { teams } from '../../../../utils/teams.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    teamId: z.string()
+        .refine(val => validation.isValidGuid(val), {
+        message: 'The value must be a valid GUID.'
+    })
+        .optional()
+        .alias('i'),
+    teamName: z.string()
+        .optional(),
+    type: z.enum(['standard', 'private', 'shared'])
+        .optional()
+        .transform(v => v?.toLowerCase())
+});
 class TeamsChannelListCommand extends GraphCommand {
     get name() {
         return commands.CHANNEL_LIST;
@@ -19,13 +29,18 @@ class TeamsChannelListCommand extends GraphCommand {
     defaultProperties() {
         return ['id', 'displayName'];
     }
-    constructor() {
-        super();
-        _TeamsChannelListCommand_instances.add(this);
-        __classPrivateFieldGet(this, _TeamsChannelListCommand_instances, "m", _TeamsChannelListCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelListCommand_instances, "m", _TeamsChannelListCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelListCommand_instances, "m", _TeamsChannelListCommand_initValidators).call(this);
-        __classPrivateFieldGet(this, _TeamsChannelListCommand_instances, "m", _TeamsChannelListCommand_initOptionSets).call(this);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(opts => [opts.teamId, opts.teamName].filter(x => x !== undefined).length === 1, {
+            message: 'Specify either teamId or teamName, but not both.',
+            params: {
+                customCode: 'optionSet',
+                options: ['teamId', 'teamName']
+            }
+        });
     }
     async getTeamId(args) {
         if (args.options.teamId) {
@@ -48,34 +63,5 @@ class TeamsChannelListCommand extends GraphCommand {
         }
     }
 }
-_TeamsChannelListCommand_instances = new WeakSet(), _TeamsChannelListCommand_initTelemetry = function _TeamsChannelListCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            teamId: typeof args.options.teamId !== 'undefined',
-            teamName: typeof args.options.teamName !== 'undefined'
-        });
-    });
-}, _TeamsChannelListCommand_initOptions = function _TeamsChannelListCommand_initOptions() {
-    this.options.unshift({
-        option: '-i, --teamId [teamId]'
-    }, {
-        option: '--teamName [teamName]'
-    }, {
-        option: '--type [type]',
-        autocomplete: ['standard', 'private', 'shared']
-    });
-}, _TeamsChannelListCommand_initValidators = function _TeamsChannelListCommand_initValidators() {
-    this.validators.push(async (args) => {
-        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
-            return `${args.options.teamId} is not a valid GUID`;
-        }
-        if (args.options.type && ['standard', 'private', 'shared'].indexOf(args.options.type.toLowerCase()) === -1) {
-            return `${args.options.type} is not a valid type value. Allowed values standard|private|shared`;
-        }
-        return true;
-    });
-}, _TeamsChannelListCommand_initOptionSets = function _TeamsChannelListCommand_initOptionSets() {
-    this.optionSets.push({ options: ['teamId', 'teamName'] });
-};
 export default new TeamsChannelListCommand();
 //# sourceMappingURL=channel-list.js.map