@commercelayer/cli-plugin-metrics 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) [2025] [Commerce Layer]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# commercelayer-cli-plugin-links

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+(async () => {
+  const oclif = await import('@oclif/core')
+  await oclif.execute({development: false, dir: __dirname})
+})()

package/lib/base.d.ts

@@ -0,0 +1,47 @@
+import { type CommerceLayerClient } from '@commercelayer/sdk';
+import { Command, Args, Flags } from '@oclif/core';
+import { type MetricsFilter, type MetricsQueryBreakdown } from './common';
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        organization: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        accessToken: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    init(): Promise<any>;
+    catch(error: any): Promise<any>;
+    protected handleError(error: any, flags?: any): Promise<any>;
+    protected commercelayerInit(flags: any): CommerceLayerClient;
+    protected checkAcessTokenData(accessToken: string, flags?: any): boolean;
+    protected multivalFlag(flag?: string[]): string[];
+    protected printResponse(response: Response): Promise<void>;
+}
+export declare abstract class BaseResourceCommand extends BaseCommand {
+    static baseFlags: {
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        organization: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        accessToken: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected filterFlag(flag?: string): MetricsFilter | undefined;
+}
+export declare abstract class BaseBreakdownCommand extends BaseResourceCommand {
+    static baseFlags: {
+        by: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        field: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        operator: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        breakdown: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        organization: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        accessToken: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected breakdownFlag(flag?: string): MetricsQueryBreakdown | undefined;
+    protected printBreakdown(by: string, data: any, level?: number): void;
+}
+export { Args, Flags };

package/lib/base.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flags = exports.Args = exports.BaseBreakdownCommand = exports.BaseResourceCommand = exports.BaseCommand = void 0;
+const tslib_1 = require("tslib");
+const sdk_1 = tslib_1.__importStar(require("@commercelayer/sdk"));
+const core_1 = require("@oclif/core");
+Object.defineProperty(exports, "Args", { enumerable: true, get: function () { return core_1.Args; } });
+Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return core_1.Flags; } });
+const cli_core_1 = require("@commercelayer/cli-core");
+const common_1 = require("./common");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+const pkg = require('../package.json');
+const REQUIRED_APP_KIND = cli_core_1.clConfig.metrics.applications;
+class BaseCommand extends core_1.Command {
+    static baseFlags = {
+        organization: core_1.Flags.string({
+            char: 'o',
+            description: 'the slug of your organization',
+            required: true,
+            env: 'CL_CLI_ORGANIZATION',
+            hidden: true
+        }),
+        domain: core_1.Flags.string({
+            char: 'd',
+            required: false,
+            hidden: true,
+            dependsOn: ['organization'],
+            env: 'CL_CLI_DOMAIN'
+        }),
+        accessToken: core_1.Flags.string({
+            char: 'a',
+            description: 'custom access token to use instead of the one used for login',
+            hidden: true,
+            required: true,
+            env: 'CL_CLI_ACCESS_TOKEN',
+            dependsOn: ['organization']
+        })
+    };
+    // INIT (override)
+    async init() {
+        cli_core_1.clUpdate.checkUpdate(pkg);
+        return await super.init();
+    }
+    async catch(error) {
+        return await this.handleError(error);
+    }
+    async handleError(error, flags) {
+        if (sdk_1.CommerceLayerStatic.isApiError(error)) {
+            if (error.status === 401) {
+                const err = error.first();
+                this.error(cli_core_1.clColor.msg.error(`${err.title}:  ${err.detail}`), { suggestions: ['Execute login to get access to the organization\'s resources'] });
+            }
+            else
+                this.error(cli_core_1.clOutput.formatError(error, flags));
+        }
+        else
+            return await super.catch(error);
+    }
+    commercelayerInit(flags) {
+        const organization = flags.organization;
+        const domain = flags.domain;
+        const accessToken = flags.accessToken;
+        const userAgent = cli_core_1.clUtil.userAgent(this.config);
+        return (0, sdk_1.default)({
+            organization,
+            domain,
+            accessToken,
+            userAgent
+        });
+    }
+    checkAcessTokenData(accessToken, flags) {
+        const info = cli_core_1.clToken.decodeAccessToken(accessToken);
+        if (info === null)
+            this.error('Invalid access token provided');
+        else if (!REQUIRED_APP_KIND.includes(info.application.kind)) // Application
+            this.error(`Invalid application kind: ${cli_core_1.clColor.msg.error(info.application.kind)}. Only these access tokens can be used: [${REQUIRED_APP_KIND.join(', ')}]`);
+        else if (info.organization?.slug !== flags.organization) // Organization
+            this.error(`The access token provided belongs to a wrong organization: ${cli_core_1.clColor.msg.error(info.organization?.slug)} instead of ${cli_core_1.clColor.style.organization(flags.organization)}`);
+        return true;
+    }
+    multivalFlag(flag) {
+        const values = [];
+        if (flag) {
+            const flagValues = flag.map(f => f.split(',').map(t => t.trim()));
+            flagValues.forEach(a => values.push(...a));
+        }
+        return values;
+    }
+    async printResponse(response) {
+        if (cliux.action.running)
+            cliux.action.stop(response.ok ? cli_core_1.clColor.msg.success('Done') : cli_core_1.clColor.msg.error('Error'));
+        const jsonRes = await response.json();
+        this.log();
+        if (response.ok)
+            this.log(cli_core_1.clOutput.formatOutput(jsonRes.data));
+        else
+            this.log(cli_core_1.clOutput.formatError(jsonRes));
+        this.log();
+    }
+}
+exports.BaseCommand = BaseCommand;
+class BaseResourceCommand extends BaseCommand {
+    static baseFlags = {
+        ...BaseCommand.baseFlags,
+        filter: core_1.Flags.string({
+            char: 'F',
+            description: 'the filter to apply to the query in JSON format (enclosed in single quotes)'
+        })
+    };
+    static args = {
+        resource: core_1.Args.string({ resource: 'the resource name', options: common_1.resources, required: true })
+    };
+    filterFlag(flag) {
+        let filter;
+        if (flag) {
+            try {
+                filter = JSON.parse(flag);
+            }
+            catch (error) {
+                this.error(`Invalid ${cli_core_1.clColor.cli.flag('filter')} format. Please provide a valid JSON string`);
+            }
+        }
+        return filter;
+    }
+}
+exports.BaseResourceCommand = BaseResourceCommand;
+class BaseBreakdownCommand extends BaseResourceCommand {
+    static baseFlags = {
+        ...BaseResourceCommand.baseFlags,
+        by: core_1.Flags.string({
+            char: 'b',
+            description: 'the field you want the results of the query aggragated by',
+            required: true
+        }),
+        field: core_1.Flags.string({
+            char: 'f',
+            description: 'the field you want the metrics or statistics computed on',
+            required: true
+        }),
+        operator: core_1.Flags.string({
+            char: 'O',
+            aliases: ['op'],
+            summary: 'the computing operator',
+            description: 'the list of valid operators depends on the value of the field key',
+            options: common_1.operators,
+            required: true,
+        }),
+        breakdown: core_1.Flags.string({
+            char: 'B',
+            summary: 'the optional nested breakdown',
+            description: 'a JSON object (enclosed in single quotes) containing the nested breakdown',
+        })
+    };
+    static args = {
+        ...BaseResourceCommand.args
+    };
+    breakdownFlag(flag) {
+        let breakdown;
+        if (flag) {
+            try {
+                breakdown = JSON.parse(flag);
+            }
+            catch (error) {
+                this.error(`Invalid ${cli_core_1.clColor.msg.error('breakdown')} format. Please provide a valid JSON string`);
+            }
+        }
+        return breakdown;
+    }
+    printBreakdown(by, data, level = 0) {
+        const tab = '  '.repeat(level);
+        this.log(`${tab}${cli_core_1.clColor.cyanBright(by)}: [`);
+        const items = data[by] || [];
+        for (const item of items) {
+            this.log(`${tab}  ${item.label}: ${cli_core_1.clColor.yellow(item.value)}`);
+            const extraFields = Object.keys(item).filter((field) => !['label', 'value', 'date'].includes(String(field)));
+            const nestedBreakdown = (extraFields.length > 0) ? extraFields[0] : undefined;
+            if (nestedBreakdown)
+                this.printBreakdown(nestedBreakdown, item, level + 1);
+        }
+        this.log(`${tab}]`);
+    }
+}
+exports.BaseBreakdownCommand = BaseBreakdownCommand;

package/lib/commands/metrics/breakdown.d.ts

@@ -0,0 +1,18 @@
+import { BaseBreakdownCommand } from '../../base';
+import type { MetricsCondition, MetricsOperation } from '../../common';
+export default class MetricsBreakdown extends BaseBreakdownCommand {
+    static operation: MetricsOperation;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        condition: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected conditionFlag(flag?: string): MetricsCondition | undefined;
+}

package/lib/commands/metrics/breakdown.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cli_core_1 = require("@commercelayer/cli-core");
+const base_1 = require("../../base");
+const common_1 = require("../../common");
+const request_1 = require("../../request");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+class MetricsBreakdown extends base_1.BaseBreakdownCommand {
+    static operation = 'breakdown';
+    static aliases = ['metrics:break', MetricsBreakdown.operation];
+    static description = 'perform a breakdown query on the Metrics API endpoint';
+    static examples = [
+        'commercelayer metrics:breakdown orders -b order.country_code -f order.id -O value_count -s desc -l 20',
+        'cl breakdown orders -b order.country_code -f order.id -O value_count -s desc -l 20 -B \'{"by": "line_items.name","field": "line_items.id","operator": "value_count","sort": "desc","limit": 20}\'',
+    ];
+    static flags = {
+        condition: base_1.Flags.string({
+            char: 'c',
+            summary: 'an additional constraint to fine-tune the set of records',
+            description: 'the condition is applied to the computed results of the query and it is available for operators that return single numeric (float or integer) values.'
+        }),
+        sort: base_1.Flags.string({
+            char: 's',
+            description: 'the way you want the results of the query to be sorted',
+            options: common_1.sorts
+        }),
+        limit: base_1.Flags.integer({
+            char: 'l',
+            description: 'the maximum number of records shown in the response',
+            min: 1,
+            max: 100
+        })
+    };
+    static args = {
+        ...base_1.BaseResourceCommand.args
+    };
+    async run() {
+        const { args, flags } = await this.parse(MetricsBreakdown);
+        this.checkAcessTokenData(flags.accessToken, flags);
+        const resource = args.resource;
+        const operator = flags.operator;
+        const condition = this.conditionFlag(flags.condition);
+        const sort = flags.sort;
+        const breakdown = this.breakdownFlag(flags.breakdown);
+        const queryBreakdown = {
+            by: flags.by,
+            field: flags.field,
+            operator,
+            condition,
+            sort,
+            limit: flags.limit,
+            breakdown
+        };
+        const filterObject = this.filterFlag(flags.filter);
+        const query = {
+            breakdown: queryBreakdown,
+            filter: filterObject
+        };
+        const response = await (0, request_1.metricsRequest)(MetricsBreakdown.operation, query, resource, flags);
+        if (response.ok) {
+            const breakdown0 = (await response.json()).data;
+            cliux.action.stop(cli_core_1.clColor.msg.success('Done'));
+            this.log();
+            this.printBreakdown(flags.by, breakdown0);
+            this.log();
+        }
+        else
+            await this.printResponse(response);
+    }
+    conditionFlag(flag) {
+        let condition;
+        if (flag) {
+            const eqi = flag.indexOf('=');
+            if (eqi < 1)
+                this.error(`Invalid condition flag: ${cli_core_1.clColor.msg.error(flag)}`, {
+                    suggestions: [`Condition flag must be defined using the format ${cli_core_1.clColor.cli.value('name=value')}`]
+                });
+            // Condition name and value
+            const name = flag.substring(0, eqi);
+            if (!common_1.conditions.includes(name))
+                this.error(`Invalid condition name: ${cli_core_1.clColor.msg.error(name)}`, {
+                    suggestions: [`Condition name must be one of the following: ${cli_core_1.clColor.cli.value(common_1.conditions.join(', '))}`]
+                });
+            const value = flag.substring(eqi + 1, flag.length);
+            const usi = name.indexOf('_');
+            if (usi > 0) { // interval condition
+                const values = value.split(',');
+                if (values.length !== 2)
+                    this.error(`Invalid condition value: ${cli_core_1.clColor.msg.error(value)}`, {
+                        suggestions: [`Interval condition flag must be defined using the format ${cli_core_1.clColor.cli.value('name=from,to')}`]
+                    });
+                const from = values[0];
+                const to = values[1];
+                condition = { [name]: [from, to] };
+            }
+            else
+                condition = { [name]: value };
+        }
+        return condition;
+    }
+}
+exports.default = MetricsBreakdown;

package/lib/commands/metrics/date_breakdown.d.ts

@@ -0,0 +1,16 @@
+import { BaseBreakdownCommand } from '../../base';
+import type { MetricsOperator } from '../../common';
+export default class MetricsDateBreakdown extends BaseBreakdownCommand {
+    static operation: string;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected printDateBreakdown(operator: MetricsOperator, data: any, level?: number): void;
+}

package/lib/commands/metrics/date_breakdown.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cli_core_1 = require("@commercelayer/cli-core");
+const base_1 = require("../../base");
+const common_1 = require("../../common");
+const request_1 = require("../../request");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+class MetricsDateBreakdown extends base_1.BaseBreakdownCommand {
+    static operation = 'date_breakdown';
+    static aliases = ['metrics:breakdate', 'metrics:date', 'breakdate', MetricsDateBreakdown.operation];
+    static description = 'perform a date breakdown query on the Metrics API endpoint';
+    static examples = [
+        'commercelayer metrics:date_breakdown orders -b order.placed_at -f order.total_amount_with_taxes -O stats -i month'
+    ];
+    static flags = {
+        interval: base_1.Flags.string({
+            char: 'i',
+            description: 'the time interval over which the metrics are computed',
+            options: common_1.intervals
+        })
+    };
+    static args = {
+        ...base_1.BaseResourceCommand.args
+    };
+    async run() {
+        const { args, flags } = await this.parse(MetricsDateBreakdown);
+        this.checkAcessTokenData(flags.accessToken, flags);
+        const resource = args.resource;
+        const operator = flags.operator;
+        const interval = flags.interval;
+        const breakdown = this.breakdownFlag(flags.breakdown);
+        const queryBreakdown = {
+            by: flags.by,
+            field: flags.field,
+            operator,
+            interval,
+            breakdown
+        };
+        const filterObject = this.filterFlag(flags.filter);
+        const query = {
+            date_breakdown: queryBreakdown,
+            filter: filterObject
+        };
+        const response = await (0, request_1.metricsRequest)(MetricsDateBreakdown.operation, query, resource, flags);
+        if (response.ok) {
+            const dateBreakdown = (await response.json()).data;
+            cliux.action.stop(cli_core_1.clColor.msg.success('Done'));
+            this.log();
+            this.printDateBreakdown(operator, dateBreakdown);
+            this.log();
+        }
+        else
+            await this.printResponse(response);
+    }
+    printDateBreakdown(operator, data, level = 0) {
+        if (level === 0)
+            cliux.action.stop(cli_core_1.clColor.msg.success('Done'));
+        const operatorInfo = common_1.operatorMap[operator];
+        this.log('----------------------------------------');
+        for (const item of data) {
+            this.log(`date: ${cli_core_1.clColor.magenta(cli_core_1.clOutput.cleanDate(String(item.date)))}`);
+            if (operatorInfo.type === 'Object') {
+                this.log(`${operator} = {`);
+                ['count', 'min', 'max', 'avg', 'sum'].forEach((op) => {
+                    this.log(`  ${op.padStart(5, ' ')}: ${cli_core_1.clColor.yellow(item.value[op])}`);
+                });
+                this.log('}');
+            }
+            else
+                this.log(`${operator} = ${cli_core_1.clColor.yellow(item.value)}`);
+            const extraFields = Object.keys(item).filter((field) => !['label', 'value', 'date'].includes(String(field)));
+            const nestedBreakdown = (extraFields.length > 0) ? extraFields[0] : undefined;
+            if (nestedBreakdown)
+                this.printBreakdown(nestedBreakdown, item, level);
+            this.log('----------------------------------------');
+        }
+    }
+}
+exports.default = MetricsDateBreakdown;

package/lib/commands/metrics/fbt.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class MetricsFbt extends BaseCommand {
+    static operation: string;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        in: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/metrics/fbt.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const request_1 = require("../../request");
+const cli_core_1 = require("@commercelayer/cli-core");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+class MetricsFbt extends base_1.BaseCommand {
+    static operation = 'fbt';
+    static aliases = [MetricsFbt.operation];
+    static description = 'perform a Frequently Bought Together query on the Metrics API analysis endpoint';
+    static examples = [
+        'commercelayer metrics:fbt --in xYZkjABcde,yzXKjYzaCx'
+    ];
+    static flags = {
+        in: core_1.Flags.string({
+            char: 'i',
+            description: 'a list of SKU or bundle IDs associated as line items to one or more orders',
+            required: true,
+            multiple: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(MetricsFbt);
+        this.checkAcessTokenData(flags.accessToken, flags);
+        const ids = this.multivalFlag(flags.in);
+        const query = {
+            filter: {
+                line_items: {
+                    item_ids: {
+                        in: ids
+                    }
+                }
+            }
+        };
+        const response = await (0, request_1.metricsRequest)(MetricsFbt.operation, query, undefined, flags);
+        if (response.ok) {
+            cliux.action.stop(cli_core_1.clColor.msg.success('Done'));
+            const jsonRes = await response.json();
+            const data = jsonRes.data;
+            if (data?.length > 0)
+                this.log(String(data));
+            else
+                this.log(cli_core_1.clColor.dim(String('\nNo data found for the given SKU or bundle IDs\n')));
+        }
+        else
+            await this.printResponse(response);
+    }
+}
+exports.default = MetricsFbt;

package/lib/commands/metrics/noc.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Noc extends Command {
+    static hidden: boolean;
+    static flags: {};
+    run(): Promise<any>;
+}

package/lib/commands/metrics/noc.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+class Noc extends core_1.Command {
+    static hidden = true;
+    static flags = {};
+    async run() {
+        const output = '-= NoC =-';
+        this.log(output);
+        return output;
+    }
+}
+exports.default = Noc;

package/lib/commands/metrics/search.d.ts

@@ -0,0 +1,19 @@
+import { BaseResourceCommand } from '../../base';
+import type { MetricsOperation } from '../../common';
+export default class MetricsSearch extends BaseResourceCommand {
+    static operation: MetricsOperation;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sort_by: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}