@pnp/cli-microsoft365 9.0.0-beta.62575a1 → 9.0.0-beta.d6b190a

package/dist/Auth.js

@@ -1,4 +1,5 @@
 import { AzureCloudInstance } from '@azure/msal-common';
+import assert from 'assert';
 import { CommandError } from './Command.js';
 import { FileTokenStorage } from './auth/FileTokenStorage.js';
 import { msalCachePlugin } from './auth/msalCachePlugin.js';
@@ -6,16 +7,15 @@ import { cli } from './cli/cli.js';
 import config from './config.js';
 import request from './request.js';
 import { settingsNames } from './settingsNames.js';
-import { browserUtil } from './utils/browserUtil.js';
 import * as accessTokenUtil from './utils/accessToken.js';
-import assert from 'assert';
+import { browserUtil } from './utils/browserUtil.js';
 export var CloudType;
 (function (CloudType) {
-    CloudType[CloudType["Public"] = 0] = "Public";
-    CloudType[CloudType["USGov"] = 1] = "USGov";
-    CloudType[CloudType["USGovHigh"] = 2] = "USGovHigh";
-    CloudType[CloudType["USGovDoD"] = 3] = "USGovDoD";
-    CloudType[CloudType["China"] = 4] = "China";
+    CloudType["Public"] = "Public";
+    CloudType["USGov"] = "USGov";
+    CloudType["USGovHigh"] = "USGovHigh";
+    CloudType["USGovDoD"] = "USGovDoD";
+    CloudType["China"] = "China";
 })(CloudType || (CloudType = {}));
 export class Connection {
     constructor() {
@@ -710,7 +710,7 @@ export class Auth {
         return details;
     }
 }
-Auth.cloudEndpoints = [];
+Auth.cloudEndpoints = {};
 Auth.initialize();
 export default new Auth();
 //# sourceMappingURL=Auth.js.map

package/dist/Command.js

@@ -5,6 +5,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Command_instances, _Command_initTelemetry, _Command_initOptions, _Command_initValidators;
 import os from 'os';
+import { z } from 'zod';
 import auth from './Auth.js';
 import { cli } from './cli/cli.js';
 import request from './request.js';
@@ -13,6 +14,7 @@ import { telemetry } from './telemetry.js';
 import { accessToken } from './utils/accessToken.js';
 import { md } from './utils/md.js';
 import { prompt } from './utils/prompt.js';
+import { zod } from './utils/zod.js';
 export class CommandError {
     constructor(message, code) {
         this.message = message;
@@ -25,10 +27,26 @@ export class CommandErrorWithOutput {
         this.stderr = stderr;
     }
 }
+export const globalOptionsZod = z.object({
+    query: z.string().optional(),
+    output: zod.alias('o', z.enum(['csv', 'json', 'md', 'text', 'none']).optional()),
+    debug: z.boolean().default(false),
+    verbose: z.boolean().default(false)
+});
 class Command {
     get allowedOutputs() {
         return ['csv', 'json', 'md', 'text', 'none'];
     }
+    get schema() {
+        return undefined;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getRefinedSchema(schema) {
+        return undefined;
+    }
+    getSchemaToParse() {
+        return this.getRefinedSchema(this.schema) ?? this.schema;
+    }
     constructor() {
         // These functions must be defined with # so that they're truly private
         // otherwise you'll get a ts2415 error (Types have separate declarations of
@@ -48,6 +66,9 @@ class Command {
             string: []
         };
         this.validators = [];
+        // metadata for command's options
+        // used for building telemetry
+        this.optionsInfo = [];
         __classPrivateFieldGet(this, _Command_instances, "m", _Command_initTelemetry).call(this);
         __classPrivateFieldGet(this, _Command_instances, "m", _Command_initOptions).call(this);
         __classPrivateFieldGet(this, _Command_instances, "m", _Command_initValidators).call(this);
@@ -410,8 +431,34 @@ class Command {
         return '';
     }
     getTelemetryProperties(args) {
-        this.telemetry.forEach(t => t(args));
-        return this.telemetryProperties;
+        if (this.schema) {
+            const telemetryProperties = {};
+            this.optionsInfo.forEach(o => {
+                if (o.required) {
+                    return;
+                }
+                if (typeof args.options[o.name] === 'undefined') {
+                    return;
+                }
+                switch (o.type) {
+                    case 'string':
+                        telemetryProperties[o.name] = o.autocomplete ? args.options[o.name] : typeof args.options[o.name] !== 'undefined';
+                        break;
+                    case 'boolean':
+                        telemetryProperties[o.name] = args.options[o.name];
+                        break;
+                    case 'number':
+                        telemetryProperties[o.name] = typeof args.options[o.name] !== 'undefined';
+                        break;
+                }
+                ;
+            });
+            return telemetryProperties;
+        }
+        else {
+            this.telemetry.forEach(t => t(args));
+            return this.telemetryProperties;
+        }
     }
     async getTextOutput(logStatement) {
         // display object as a list of key-value pairs

package/dist/cli/cli.js

@@ -1,22 +1,24 @@
 import Configstore from 'configstore';
 import fs from 'fs';
-import minimist from 'minimist';
 import { createRequire } from 'module';
 import os from 'os';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import yargs from 'yargs-parser';
+import { ZodError } from 'zod';
 import Command, { CommandError } from '../Command.js';
 import config from '../config.js';
 import request from '../request.js';
 import { settingsNames } from '../settingsNames.js';
 import { telemetry } from '../telemetry.js';
 import { app } from '../utils/app.js';
+import { browserUtil } from '../utils/browserUtil.js';
 import { formatting } from '../utils/formatting.js';
 import { md } from '../utils/md.js';
-import { validation } from '../utils/validation.js';
 import { prompt } from '../utils/prompt.js';
+import { validation } from '../utils/validation.js';
+import { zod } from '../utils/zod.js';
 import { timings } from './timings.js';
-import { browserUtil } from '../utils/browserUtil.js';
 const require = createRequire(import.meta.url);
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 let _config;
@@ -64,7 +66,7 @@ async function execute(rawArgs) {
         rawArgs.shift();
     }
     // parse args to see if a command has been specified
-    const parsedArgs = minimist(rawArgs);
+    const parsedArgs = yargs(rawArgs);
     // load command
     await cli.loadCommandFromArgs(parsedArgs._);
     if (cli.commandToExecute) {
@@ -77,8 +79,7 @@ async function execute(rawArgs) {
             };
         }
         catch (e) {
-            const optionsWithoutShorts = removeShortOptions({ options: parsedArgs });
-            return cli.closeWithError(e.message, optionsWithoutShorts, false);
+            return cli.closeWithError(e.message, { options: parsedArgs }, false);
         }
     }
     else {
@@ -126,18 +127,30 @@ async function execute(rawArgs) {
     if (cli.optionsFromArgs.options.output === undefined) {
         cli.optionsFromArgs.options.output = cli.getSettingWithDefaultValue(settingsNames.output, 'json');
     }
-    const startValidation = process.hrtime.bigint();
-    const validationResult = await cli.commandToExecute.command.validate(cli.optionsFromArgs, cli.commandToExecute);
-    const endValidation = process.hrtime.bigint();
-    timings.validation.push(Number(endValidation - startValidation));
-    if (validationResult !== true) {
-        return cli.closeWithError(validationResult, cli.optionsFromArgs, true);
+    let finalArgs = cli.optionsFromArgs.options;
+    if (cli.commandToExecute?.command.schema) {
+        const startValidation = process.hrtime.bigint();
+        const result = cli.commandToExecute.command.getSchemaToParse().safeParse(cli.optionsFromArgs.options);
+        const endValidation = process.hrtime.bigint();
+        timings.validation.push(Number(endValidation - startValidation));
+        if (!result.success) {
+            return cli.closeWithError(result.error, cli.optionsFromArgs, true);
+        }
+        finalArgs = result.data;
+    }
+    else {
+        const startValidation = process.hrtime.bigint();
+        const validationResult = await cli.commandToExecute.command.validate(cli.optionsFromArgs, cli.commandToExecute);
+        const endValidation = process.hrtime.bigint();
+        timings.validation.push(Number(endValidation - startValidation));
+        if (validationResult !== true) {
+            return cli.closeWithError(validationResult, cli.optionsFromArgs, true);
+        }
     }
-    cli.optionsFromArgs = removeShortOptions(cli.optionsFromArgs);
     const end = process.hrtime.bigint();
     timings.core.push(Number(end - start));
     try {
-        await cli.executeCommand(cli.commandToExecute.command, cli.optionsFromArgs);
+        await cli.executeCommand(cli.commandToExecute.command, { options: finalArgs });
         const endTotal = process.hrtime.bigint();
         timings.total.push(Number(endTotal - start));
         await printTimings(rawArgs);
@@ -347,12 +360,14 @@ async function loadCommandFromFile(commandFileUrl) {
     catch { }
 }
 function getCommandInfo(command, filePath = '', helpFilePath = '') {
+    const options = command.schema ? zod.schemaToOptions(command.schema) : getCommandOptions(command);
+    command.optionsInfo = options;
     return {
         aliases: command.alias(),
         name: command.name,
         description: command.description,
         command: command,
-        options: getCommandOptions(command),
+        options,
         defaultProperties: command.defaultProperties(),
         file: filePath,
         help: helpFilePath
@@ -387,36 +402,47 @@ function getCommandOptions(command) {
     return options;
 }
 function getCommandOptionsFromArgs(args, commandInfo) {
-    const minimistOptions = {
-        alias: {}
+    const yargsOptions = {
+        alias: {},
+        configuration: {
+            "parse-numbers": false,
+            "strip-aliased": true,
+            "strip-dashed": true
+        }
     };
     let argsToParse = args;
     if (commandInfo) {
-        const commandTypes = commandInfo.command.types;
-        if (commandTypes) {
-            minimistOptions.string = commandTypes.string;
-            // minimist will parse unused boolean options to 'false' (unused options => options that are not included in the args)
-            // But in the CLI booleans are nullable. They can can be true, false or undefined.
-            // For this reason we only pass boolean types that are actually used as arg.
-            minimistOptions.boolean = commandTypes.boolean.filter(optionName => args.some(arg => `--${optionName}` === arg || `-${optionName}` === arg));
-        }
-        minimistOptions.alias = {};
+        if (commandInfo.command.schema) {
+            yargsOptions.string = commandInfo.options.filter(o => o.type === 'string').map(o => o.name);
+            yargsOptions.boolean = commandInfo.options.filter(o => o.type === 'boolean').map(o => o.name);
+            yargsOptions.number = commandInfo.options.filter(o => o.type === 'number').map(o => o.name);
+            argsToParse = getRewrittenArgs(args, yargsOptions.boolean);
+        }
+        else {
+            const commandTypes = commandInfo.command.types;
+            if (commandTypes) {
+                yargsOptions.string = commandTypes.string;
+                // minimist will parse unused boolean options to 'false' (unused options => options that are not included in the args)
+                // But in the CLI booleans are nullable. They can can be true, false or undefined.
+                // For this reason we only pass boolean types that are actually used as arg.
+                yargsOptions.boolean = commandTypes.boolean.filter(optionName => args.some(arg => `--${optionName}` === arg || `-${optionName}` === arg));
+            }
+            argsToParse = getRewrittenArgs(args, commandTypes.boolean);
+        }
         commandInfo.options.forEach(option => {
             if (option.short && option.long) {
-                minimistOptions.alias[option.short] = option.long;
+                yargsOptions.alias[option.long] = option.short;
             }
         });
-        argsToParse = getRewrittenArgs(args, commandTypes);
     }
-    return minimist(argsToParse, minimistOptions);
+    return yargs(argsToParse, yargsOptions);
 }
 /**
  * Rewrites arguments (if necessary) before passing them into minimist.
  * Currently only boolean values are checked and fixed.
  * Args are only checked and rewritten if the option has been added to the 'types.boolean' array.
  */
-function getRewrittenArgs(args, commandTypes) {
-    const booleanTypes = commandTypes.boolean;
+function getRewrittenArgs(args, booleanTypes) {
     if (booleanTypes.length === 0) {
         return args;
     }
@@ -722,6 +748,9 @@ async function closeWithError(error, args, showHelpIfEnabled = false) {
         return process.exit(exitCode);
     }
     let errorMessage = error instanceof CommandError ? error.message : error;
+    if (error instanceof ZodError) {
+        errorMessage = error.errors.map(e => `${e.path}: ${e.message}`).join(os.EOL);
+    }
     if ((!args.options.output || args.options.output === 'json') &&
         !cli.getSettingWithDefaultValue(settingsNames.printErrorsAsPlainText, true)) {
         errorMessage = JSON.stringify({ error: errorMessage });
@@ -780,13 +809,6 @@ async function handleMultipleResultsFound(message, values) {
     const response = await cli.promptForSelection({ message: `Please choose one:`, choices });
     return values[response];
 }
-function removeShortOptions(args) {
-    const filteredArgs = JSON.parse(JSON.stringify(args));
-    const optionsToRemove = Object.getOwnPropertyNames(args.options)
-        .filter(option => option.length === 1 || option === '--');
-    optionsToRemove.forEach(option => delete filteredArgs.options[option]);
-    return filteredArgs;
-}
 function loadOptionValuesFromFiles(args) {
     const optionNames = Object.getOwnPropertyNames(args.options);
     optionNames.forEach(option => {

package/dist/m365/commands/login.js

@@ -1,17 +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 _LoginCommand_instances, _a, _LoginCommand_initTelemetry, _LoginCommand_initOptions, _LoginCommand_initValidators;
 import fs from 'fs';
+import { z } from 'zod';
 import auth, { AuthType, CloudType } from '../../Auth.js';
-import Command, { CommandError } from '../../Command.js';
+import Command, { CommandError, globalOptionsZod } from '../../Command.js';
+import { cli } from '../../cli/cli.js';
 import config from '../../config.js';
-import { misc } from '../../utils/misc.js';
-import commands from './commands.js';
 import { settingsNames } from '../../settingsNames.js';
-import { cli } from '../../cli/cli.js';
+import { zod } from '../../utils/zod.js';
+import commands from './commands.js';
+const options = globalOptionsZod
+    .extend({
+    authType: zod.alias('t', z.enum(['certificate', 'deviceCode', 'password', 'identity', 'browser', 'secret']).optional()),
+    cloud: z.nativeEnum(CloudType).optional().default(CloudType.Public),
+    userName: zod.alias('u', z.string().optional()),
+    password: zod.alias('p', z.string().optional()),
+    certificateFile: zod.alias('c', z.string().optional()
+        .refine(filePath => !filePath || fs.existsSync(filePath), filePath => ({
+        message: `Certificate file ${filePath} does not exist`
+    }))),
+    certificateBase64Encoded: z.string().optional(),
+    thumbprint: z.string().optional(),
+    appId: z.string().optional(),
+    tenant: z.string().optional(),
+    secret: zod.alias('s', z.string().optional()),
+    connectionName: z.string().optional()
+})
+    .strict();
 class LoginCommand extends Command {
     get name() {
         return commands.LOGIN;
@@ -19,12 +32,26 @@ class LoginCommand extends Command {
     get description() {
         return 'Log in to Microsoft 365';
     }
-    constructor() {
-        super();
-        _LoginCommand_instances.add(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initValidators).call(this);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => options.authType !== 'password' || options.userName, {
+            message: 'Username is required when using password authentication'
+        })
+            .refine(options => options.authType !== 'password' || options.password, {
+            message: 'Password is required when using password authentication'
+        })
+            .refine(options => options.authType !== 'certificate' || !(options.certificateFile && options.certificateBase64Encoded), {
+            message: 'Specify either certificateFile or certificateBase64Encoded, but not both.'
+        })
+            .refine(options => options.authType !== 'certificate' || options.certificateFile || options.certificateBase64Encoded, {
+            message: 'Specify either certificateFile or certificateBase64Encoded'
+        })
+            .refine(options => options.authType !== 'secret' || options.secret, {
+            message: 'Secret is required when using secret authentication'
+        });
     }
     async commandAction(logger, args) {
         // disconnect before re-connecting
@@ -64,12 +91,7 @@ class LoginCommand extends Command {
                     auth.connection.secret = args.options.secret;
                     break;
             }
-            if (args.options.cloud) {
-                auth.connection.cloudType = CloudType[args.options.cloud];
-            }
-            else {
-                auth.connection.cloudType = CloudType.Public;
-            }
+            auth.connection.cloudType = args.options.cloud;
             try {
                 await auth.ensureAccessToken(auth.defaultResource, logger, this.debug);
                 auth.connection.active = true;
@@ -102,79 +124,5 @@ class LoginCommand extends Command {
         await this.commandAction(logger, args);
     }
 }
-_a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTelemetry = function _LoginCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            authType: args.options.authType || cli.getSettingWithDefaultValue(settingsNames.authType, 'deviceCode'),
-            cloud: args.options.cloud ?? CloudType.Public
-        });
-    });
-}, _LoginCommand_initOptions = function _LoginCommand_initOptions() {
-    this.options.unshift({
-        option: '-t, --authType [authType]',
-        autocomplete: _a.allowedAuthTypes
-    }, {
-        option: '-u, --userName [userName]'
-    }, {
-        option: '-p, --password [password]'
-    }, {
-        option: '-c, --certificateFile [certificateFile]'
-    }, {
-        option: '--certificateBase64Encoded [certificateBase64Encoded]'
-    }, {
-        option: '--thumbprint [thumbprint]'
-    }, {
-        option: '--appId [appId]'
-    }, {
-        option: '--tenant [tenant]'
-    }, {
-        option: '-s, --secret [secret]'
-    }, {
-        option: '--cloud [cloud]',
-        autocomplete: misc.getEnums(CloudType)
-    }, {
-        option: '--connectionName [connectionName]'
-    });
-}, _LoginCommand_initValidators = function _LoginCommand_initValidators() {
-    this.validators.push(async (args) => {
-        const authType = args.options.authType || cli.getSettingWithDefaultValue(settingsNames.authType, 'deviceCode');
-        if (authType === 'password') {
-            if (!args.options.userName) {
-                return 'Required option userName missing';
-            }
-            if (!args.options.password) {
-                return 'Required option password missing';
-            }
-        }
-        if (authType === 'certificate') {
-            if (args.options.certificateFile && args.options.certificateBase64Encoded) {
-                return 'Specify either certificateFile or certificateBase64Encoded, but not both.';
-            }
-            if (!args.options.certificateFile && !args.options.certificateBase64Encoded) {
-                return 'Specify either certificateFile or certificateBase64Encoded';
-            }
-            if (args.options.certificateFile) {
-                if (!fs.existsSync(args.options.certificateFile)) {
-                    return `File '${args.options.certificateFile}' does not exist`;
-                }
-            }
-        }
-        if (authType &&
-            _a.allowedAuthTypes.indexOf(authType) < 0) {
-            return `'${authType}' is not a valid authentication type. Allowed authentication types are ${_a.allowedAuthTypes.join(', ')}`;
-        }
-        if (authType === 'secret') {
-            if (!args.options.secret) {
-                return 'Required option secret missing';
-            }
-        }
-        if (args.options.cloud &&
-            typeof CloudType[args.options.cloud] === 'undefined') {
-            return `${args.options.cloud} is not a valid value for cloud. Valid options are ${misc.getEnums(CloudType).join(', ')}`;
-        }
-        return true;
-    });
-};
-LoginCommand.allowedAuthTypes = ['certificate', 'deviceCode', 'password', 'identity', 'browser', 'secret'];
 export default new LoginCommand();
 //# sourceMappingURL=login.js.map

package/dist/m365/spe/ContainerTypeProperties.js

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

package/dist/m365/spe/commands/containertype/containertype-list.js

@@ -0,0 +1,49 @@
+import config from '../../../../config.js';
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpeContainertypeListCommand extends SpoCommand {
+    get name() {
+        return commands.CONTAINERTYPE_LIST;
+    }
+    get description() {
+        return 'Lists all Container Types';
+    }
+    defaultProperties() {
+        return ['ContainerTypeId', 'DisplayName', 'OwningAppId'];
+    }
+    async commandAction(logger) {
+        try {
+            const spoAdminUrl = await spo.getSpoAdminUrl(logger, this.debug);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving list of Container types...`);
+            }
+            const allContainerTypes = await this.getAllContainerTypes(spoAdminUrl, logger);
+            await logger.log(allContainerTypes);
+        }
+        catch (err) {
+            this.handleRejectedPromise(err);
+        }
+    }
+    async getAllContainerTypes(spoAdminUrl, logger) {
+        const formDigestInfo = await spo.ensureFormDigest(spoAdminUrl, logger, undefined, this.debug);
+        const requestOptions = {
+            url: `${spoAdminUrl}/_vti_bin/client.svc/ProcessQuery`,
+            headers: {
+                'X-RequestDigest': formDigestInfo.FormDigestValue
+            },
+            data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="46" ObjectPathId="45" /><Method Name="GetSPOContainerTypes" Id="47" ObjectPathId="45"><Parameters><Parameter Type="Enum">1</Parameter></Parameters></Method></Actions><ObjectPaths><Constructor Id="45" TypeId="{268004ae-ef6b-4e9b-8425-127220d84719}" /></ObjectPaths></Request>`
+        };
+        const res = await request.post(requestOptions);
+        const json = JSON.parse(res);
+        const response = json[0];
+        if (response.ErrorInfo) {
+            throw response.ErrorInfo.ErrorMessage;
+        }
+        const containerTypes = json[json.length - 1];
+        return containerTypes;
+    }
+}
+export default new SpeContainertypeListCommand();
+//# sourceMappingURL=containertype-list.js.map

package/dist/m365/spe/commands.js

@@ -1,5 +1,6 @@
 const prefix = 'spe';
 export default {
-    CONTAINERTYPE_ADD: `${prefix} containertype add`
+    CONTAINERTYPE_ADD: `${prefix} containertype add`,
+    CONTAINERTYPE_LIST: `${prefix} containertype list`
 };
 //# sourceMappingURL=commands.js.map

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

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SpoApplicationCustomizerGetCommand_instances, _SpoApplicationCustomizerGetCommand_initTelemetry, _SpoApplicationCustomizerGetCommand_initOptions, _SpoApplicationCustomizerGetCommand_initValidators, _SpoApplicationCustomizerGetCommand_initOptionSets;
+var _SpoApplicationCustomizerGetCommand_instances, _SpoApplicationCustomizerGetCommand_initTelemetry, _SpoApplicationCustomizerGetCommand_initOptions, _SpoApplicationCustomizerGetCommand_initValidators, _SpoApplicationCustomizerGetCommand_initOptionSets, _SpoApplicationCustomizerGetCommand_initTypes;
 import { formatting } from '../../../../utils/formatting.js';
 import { spo } from '../../../../utils/spo.js';
 import { validation } from '../../../../utils/validation.js';
@@ -25,33 +25,22 @@ class SpoApplicationCustomizerGetCommand extends SpoCommand {
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         try {
             const customAction = await this.getCustomAction(args.options);
-            if (customAction) {
+            if (!args.options.clientSideComponentProperties) {
                 await logger.log({
-                    ClientSideComponentId: customAction.ClientSideComponentId,
-                    ClientSideComponentProperties: customAction.ClientSideComponentProperties,
-                    CommandUIExtension: customAction.CommandUIExtension,
-                    Description: customAction.Description,
-                    Group: customAction.Group,
-                    Id: customAction.Id,
-                    ImageUrl: customAction.ImageUrl,
-                    Location: customAction.Location,
-                    Name: customAction.Name,
-                    RegistrationId: customAction.RegistrationId,
-                    RegistrationType: customAction.RegistrationType,
+                    ...customAction,
                     Rights: JSON.stringify(customAction.Rights),
-                    Scope: this.humanizeScope(customAction.Scope),
-                    ScriptBlock: customAction.ScriptBlock,
-                    ScriptSrc: customAction.ScriptSrc,
-                    Sequence: customAction.Sequence,
-                    Title: customAction.Title,
-                    Url: customAction.Url,
-                    VersionOfUserCustomAction: customAction.VersionOfUserCustomAction
+                    Scope: this.humanizeScope(customAction.Scope)
                 });
             }
+            else {
+                const properties = formatting.tryParseJson(customAction.ClientSideComponentProperties);
+                await logger.log(properties);
+            }
         }
         catch (err) {
             this.handleRejectedPromise(err);
@@ -95,7 +84,8 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
             title: typeof args.options.title !== 'undefined',
             id: typeof args.options.id !== 'undefined',
             clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined',
-            scope: typeof args.options.scope !== 'undefined'
+            scope: typeof args.options.scope !== 'undefined',
+            clientSideComponentProperties: !!args.options.clientSideComponentProperties
         });
     });
 }, _SpoApplicationCustomizerGetCommand_initOptions = function _SpoApplicationCustomizerGetCommand_initOptions() {
@@ -110,6 +100,8 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
     }, {
         option: '-s, --scope [scope]',
         autocomplete: this.allowedScopes
+    }, {
+        option: '-p, --clientSideComponentProperties'
     });
 }, _SpoApplicationCustomizerGetCommand_initValidators = function _SpoApplicationCustomizerGetCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -126,6 +118,9 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
     });
 }, _SpoApplicationCustomizerGetCommand_initOptionSets = function _SpoApplicationCustomizerGetCommand_initOptionSets() {
     this.optionSets.push({ options: ['title', 'id', 'clientSideComponentId'] });
+}, _SpoApplicationCustomizerGetCommand_initTypes = function _SpoApplicationCustomizerGetCommand_initTypes() {
+    this.types.string.push('webUrl', 'title', 'id', 'clientSideComponentId', 'scope');
+    this.types.boolean.push('clientSideComponentProperties');
 };
 export default new SpoApplicationCustomizerGetCommand();
 //# sourceMappingURL=applicationcustomizer-get.js.map