@nickchristensen/ppls 1.0.1

package/dist/commands/documents/update.d.ts

@@ -0,0 +1,25 @@
+import type { Document, DocumentUpdate } from '../../types/documents.js';
+import { UpdateCommand } from '../../update-command.js';
+export default class DocumentsUpdate extends UpdateCommand<DocumentUpdate, Document> {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'archive-serial-number': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        content: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        correspondent: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        created: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'document-type': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'storage-path': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tag: import("@oclif/core/interfaces").OptionFlag<number[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected buildPayload(_args: unknown, flags: Record<string, unknown>): DocumentUpdate;
+    protected plainTemplate(document: Document): string | undefined;
+    protected updatePath(id: number | string): string;
+}

package/dist/commands/documents/update.js

@@ -0,0 +1,42 @@
+import { Args, Flags } from '@oclif/core';
+import { UpdateCommand } from '../../update-command.js';
+export default class DocumentsUpdate extends UpdateCommand {
+    static args = {
+        id: Args.integer({ description: 'Document id', required: true }),
+    };
+    static description = 'Update a document';
+    static examples = ['<%= config.bin %> <%= command.id %> 123 --title "Receipt"'];
+    static flags = {
+        'archive-serial-number': Flags.integer({ description: 'Archive serial number' }),
+        content: Flags.string({ description: 'Document content' }),
+        correspondent: Flags.integer({ description: 'Correspondent id' }),
+        created: Flags.string({ description: 'Document created date' }),
+        'document-type': Flags.integer({ description: 'Document type id' }),
+        'storage-path': Flags.integer({ description: 'Storage path id' }),
+        tag: Flags.integer({ description: 'Tag id (repeatable)', multiple: true }),
+        title: Flags.string({ description: 'Document title' }),
+    };
+    buildPayload(_args, flags) {
+        const typedFlags = flags;
+        return {
+            'archive_serial_number': typedFlags['archive-serial-number'],
+            content: typedFlags.content,
+            correspondent: typedFlags.correspondent,
+            created: typedFlags.created,
+            'document_type': typedFlags['document-type'],
+            'storage_path': typedFlags['storage-path'],
+            tags: typedFlags.tag,
+            title: typedFlags.title,
+        };
+    }
+    plainTemplate(document) {
+        const title = document.title?.trim();
+        if (!title) {
+            return;
+        }
+        return `[${document.id}] ${title}`;
+    }
+    updatePath(id) {
+        return `/api/documents/${id}/`;
+    }
+}

package/dist/commands/profile.d.ts

@@ -0,0 +1,13 @@
+import type { Profile } from '../types/profile.js';
+import { ShowCommand } from '../show-command.js';
+export default class ProfileCommand extends ShowCommand<Profile> {
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    protected plainTemplate(profile: Profile): string | undefined;
+    protected showId(_args: {
+        id: number | string;
+    }): number | string;
+    protected showPath(_id: number | string): string;
+    protected transformResult(profile: Profile): Profile;
+}

package/dist/commands/profile.js

@@ -0,0 +1,19 @@
+import { ShowCommand } from '../show-command.js';
+export default class ProfileCommand extends ShowCommand {
+    static aliases = ['whoami'];
+    static description = 'Show profile details';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    plainTemplate(profile) {
+        return `${profile.first_name} ${profile.last_name} <${profile.email}>`;
+    }
+    showId(_args) {
+        return '';
+    }
+    showPath(_id) {
+        return '/api/profile/';
+    }
+    transformResult(profile) {
+        delete profile.password;
+        return profile;
+    }
+}

package/dist/commands/tags/add.d.ts

@@ -0,0 +1,17 @@
+import type { Tag, TagCreate } from '../../types/tags.js';
+import { AddCommand } from '../../add-command.js';
+export default class TagsAdd extends AddCommand<TagCreate, Tag> {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        inbox: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parent: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected createPath: string;
+    protected buildPayload(args: unknown, flags: Record<string, unknown>): TagCreate;
+    protected plainTemplate(tag: Tag): string | undefined;
+}

package/dist/commands/tags/add.js

@@ -0,0 +1,29 @@
+import { Args, Flags } from '@oclif/core';
+import { AddCommand } from '../../add-command.js';
+export default class TagsAdd extends AddCommand {
+    static args = {
+        name: Args.string({ description: 'Tag name', required: true }),
+    };
+    static description = 'Create a tag';
+    static examples = ['<%= config.bin %> <%= command.id %> Inbox'];
+    static flags = {
+        color: Flags.string({ description: 'Tag color (hex value)' }),
+        inbox: Flags.boolean({ description: 'Mark tag as an inbox tag' }),
+        parent: Flags.integer({ description: 'Parent tag id' }),
+    };
+    createPath = '/api/tags/';
+    buildPayload(args, flags) {
+        const typedArgs = args;
+        const typedFlags = flags;
+        return {
+            color: typedFlags.color,
+            'is_inbox_tag': typedFlags.inbox ? true : undefined,
+            'matching_algorithm': 6,
+            name: typedArgs.name,
+            parent: typedFlags.parent,
+        };
+    }
+    plainTemplate(tag) {
+        return `[${tag.id}] ${tag.name}`;
+    }
+}

package/dist/commands/tags/delete.d.ts

@@ -0,0 +1,16 @@
+import { DeleteCommand } from '../../delete-command.js';
+export default class TagsDelete extends DeleteCommand {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected deleteLabel(id: number | string): string;
+    protected deletePath(id: number | string): string;
+}

package/dist/commands/tags/delete.js

@@ -0,0 +1,18 @@
+import { Args, Flags } from '@oclif/core';
+import { DeleteCommand } from '../../delete-command.js';
+export default class TagsDelete extends DeleteCommand {
+    static args = {
+        id: Args.integer({ description: 'Tag id', required: true }),
+    };
+    static description = 'Delete a tag';
+    static examples = ['<%= config.bin %> <%= command.id %> 123'];
+    static flags = {
+        yes: Flags.boolean({ char: 'y', description: 'Skip confirmation prompt' }),
+    };
+    deleteLabel(id) {
+        return `tag ${id}`;
+    }
+    deletePath(id) {
+        return `/api/tags/${id}/`;
+    }
+}

package/dist/commands/tags/list.d.ts

@@ -0,0 +1,10 @@
+import type { Tag, TagApi } from '../../types/tags.js';
+import { ListCommand } from '../../list-command.js';
+export default class TagsList extends ListCommand<TagApi, Tag> {
+    static description: string;
+    static examples: string[];
+    protected listPath: string;
+    protected tableAttrs: string[];
+    protected plainTemplate(tag: Tag): string | undefined;
+    protected transformResult(tag: TagApi): Tag;
+}

package/dist/commands/tags/list.js

@@ -0,0 +1,18 @@
+import { ListCommand } from '../../list-command.js';
+export default class TagsList extends ListCommand {
+    static description = 'List tags';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    listPath = '/api/tags/';
+    tableAttrs = ['id', 'name', 'slug', 'document_count'];
+    plainTemplate(tag) {
+        const count = tag.document_count;
+        const suffix = count === undefined ? '' : ` (${count} ${count === 1 ? 'document' : 'documents'})`;
+        return `[${tag.id}] ${tag.name}${suffix}`;
+    }
+    transformResult(tag) {
+        return {
+            ...tag,
+            children: tag.children.map((child) => child.id),
+        };
+    }
+}

package/dist/commands/tags/show.d.ts

@@ -0,0 +1,16 @@
+import type { Tag, TagApi } from '../../types/tags.js';
+import { ShowCommand } from '../../show-command.js';
+export declare const isHexColor: (value: string) => boolean;
+export default class TagsShow extends ShowCommand<TagApi, Tag> {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    protected plainTemplate(tag: Tag): string | undefined;
+    protected showPath(id: number | string): string;
+    protected transformResult(tag: TagApi): Tag;
+}

package/dist/commands/tags/show.js

@@ -0,0 +1,24 @@
+import { Args } from '@oclif/core';
+import { ShowCommand } from '../../show-command.js';
+export const isHexColor = (value) => /^#([0-9A-Fa-f]{3}){1,2}$/.test(value);
+export default class TagsShow extends ShowCommand {
+    static args = {
+        id: Args.integer({ description: 'Tag id', required: true }),
+    };
+    static description = 'Show tag details';
+    static examples = ['<%= config.bin %> <%= command.id %> 123'];
+    plainTemplate(tag) {
+        const count = tag.document_count;
+        const suffix = count === undefined ? '' : ` (${count} ${count === 1 ? 'document' : 'documents'})`;
+        return `[${tag.id}] ${tag.name}${suffix}`;
+    }
+    showPath(id) {
+        return `/api/tags/${id}/`;
+    }
+    transformResult(tag) {
+        return {
+            ...tag,
+            children: tag.children.map((child) => child.id),
+        };
+    }
+}

package/dist/commands/tags/update.d.ts

@@ -0,0 +1,21 @@
+import type { Tag, TagUpdate } from '../../types/tags.js';
+import { UpdateCommand } from '../../update-command.js';
+export default class TagsUpdate extends UpdateCommand<TagUpdate, Tag> {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        inbox: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        parent: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected buildPayload(_args: unknown, flags: Record<string, unknown>): TagUpdate;
+    protected plainTemplate(tag: Tag): string | undefined;
+    protected updatePath(id: number | string): string;
+}

package/dist/commands/tags/update.js

@@ -0,0 +1,30 @@
+import { Args, Flags } from '@oclif/core';
+import { UpdateCommand } from '../../update-command.js';
+export default class TagsUpdate extends UpdateCommand {
+    static args = {
+        id: Args.integer({ description: 'Tag id', required: true }),
+    };
+    static description = 'Update a tag';
+    static examples = ['<%= config.bin %> <%= command.id %> 123 --name Inbox'];
+    static flags = {
+        color: Flags.string({ description: 'Tag color (hex value)' }),
+        inbox: Flags.boolean({ allowNo: true, description: 'Mark tag as an inbox tag' }),
+        name: Flags.string({ description: 'Tag name' }),
+        parent: Flags.integer({ description: 'Parent tag id' }),
+    };
+    buildPayload(_args, flags) {
+        const typedFlags = flags;
+        return {
+            color: typedFlags.color,
+            'is_inbox_tag': typedFlags.inbox,
+            name: typedFlags.name,
+            parent: typedFlags.parent,
+        };
+    }
+    plainTemplate(tag) {
+        return `[${tag.id}] ${tag.name}`;
+    }
+    updatePath(id) {
+        return `/api/tags/${id}/`;
+    }
+}

package/dist/delete-command.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from './base-command.js';
+type DeleteCommandArgs = {
+    id: number | string;
+};
+type DeleteCommandFlags = {
+    yes?: boolean;
+};
+type DeleteCommandResult<TResponse> = null | TResponse | {
+    deleted: true;
+    id: number | string;
+};
+export declare abstract class DeleteCommand<TResponse = unknown> extends BaseCommand {
+    protected deleteId(args: DeleteCommandArgs): number | string;
+    protected abstract deleteLabel(id: number | string): string;
+    protected deleteMessage(id: number | string, _result: null | TResponse): string | undefined;
+    protected abstract deletePath(id: number | string): string;
+    protected ensureConfirmed(flags: DeleteCommandFlags, id: number | string): Promise<void>;
+    run(): Promise<DeleteCommandResult<TResponse>>;
+}
+export {};

package/dist/delete-command.js

@@ -0,0 +1,48 @@
+import { createInterface } from 'node:readline';
+import { BaseCommand } from './base-command.js';
+export class DeleteCommand extends BaseCommand {
+    deleteId(args) {
+        return args.id;
+    }
+    deleteMessage(id, _result) {
+        return `Deleted ${this.deleteLabel(id)}`;
+    }
+    async ensureConfirmed(flags, id) {
+        if (flags.yes) {
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            this.error('Confirmation required. Re-run with --yes to proceed.');
+        }
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => {
+            rl.question(`Delete ${this.deleteLabel(id)}? (y/N) `, (response) => resolve(response));
+        });
+        rl.close();
+        const confirmed = ['y', 'yes'].includes(answer.trim().toLowerCase());
+        if (!confirmed) {
+            this.exit(0);
+        }
+    }
+    async run() {
+        const { args, flags, metadata } = await this.parse();
+        const resolvedFlags = await this.resolveGlobalFlags(flags, metadata);
+        const apiFlags = {
+            headers: resolvedFlags.headers,
+            hostname: resolvedFlags.hostname,
+            token: resolvedFlags.token,
+        };
+        const deleteFlags = flags;
+        const id = this.deleteId(args);
+        await this.ensureConfirmed(deleteFlags, id);
+        const result = await this.deleteApiJson(apiFlags, this.deletePath(id));
+        if (this.jsonEnabled()) {
+            return result === null ? { deleted: true, id } : result;
+        }
+        const message = this.deleteMessage(id, result);
+        if (message) {
+            this.log(message);
+        }
+        return result;
+    }
+}

package/dist/helpers/config-store.d.ts

@@ -0,0 +1,4 @@
+export type ConfigData = Record<string, unknown>;
+export declare const configPath: (configDir: string) => string;
+export declare const readConfig: (configDir: string) => Promise<ConfigData>;
+export declare const writeConfig: (configDir: string, config: ConfigData) => Promise<void>;

package/dist/helpers/config-store.js

@@ -0,0 +1,35 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const configPath = (configDir) => path.join(configDir, 'config.json');
+export const readConfig = async (configDir) => {
+    const configFile = configPath(configDir);
+    let rawConfig;
+    try {
+        rawConfig = await readFile(configFile, 'utf8');
+    }
+    catch (error) {
+        const typedError = error;
+        if (typedError.code === 'ENOENT') {
+            return {};
+        }
+        const message = typedError.message ?? String(error);
+        throw new Error(`Failed to read config at ${configFile}: ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawConfig);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read config at ${configFile}: ${message}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Config at ${configFile} must be a JSON object.`);
+    }
+    return parsed;
+};
+export const writeConfig = async (configDir, config) => {
+    const configFile = configPath(configDir);
+    await mkdir(configDir, { recursive: true });
+    await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+};

package/dist/helpers/date-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const isDateOnly: (value: string) => boolean;
+export declare const isDateTime: (value: string) => boolean;
+export declare const formatDateString: (value: string, dateFormat: string, baseDate?: Date) => null | string;

package/dist/helpers/date-utils.js

@@ -0,0 +1,27 @@
+import { format, formatRelative, isMatch, isValid, parse, parseISO } from 'date-fns';
+const dateOnlyFormat = 'yyyy-MM-dd';
+export const isDateOnly = (value) => isMatch(value, dateOnlyFormat);
+export const isDateTime = (value) => {
+    if (!value.includes('T')) {
+        return false;
+    }
+    const parsedDate = parseISO(value);
+    if (!isValid(parsedDate)) {
+        return false;
+    }
+    return /(?:Z|[+-]\d{2}:\d{2})$/.test(value);
+};
+export const formatDateString = (value, dateFormat, baseDate = new Date()) => {
+    if (isDateOnly(value)) {
+        const parsedDate = parse(value, dateOnlyFormat, new Date());
+        if (dateFormat === 'relative') {
+            return formatRelative(parsedDate, baseDate).split(' at ')[0];
+        }
+        return format(parsedDate, dateFormat);
+    }
+    if (isDateTime(value)) {
+        const parsedDate = parseISO(value);
+        return dateFormat === 'relative' ? formatRelative(parsedDate, baseDate) : format(parsedDate, dateFormat);
+    }
+    return null;
+};

package/dist/helpers/table.d.ts

@@ -0,0 +1,20 @@
+import type * as TtyTable from 'tty-table';
+export type TableColumn = TtyTable.Header;
+export type TableFormatterContext = {
+    configure: (options: Record<string, unknown>) => void;
+    resetStyle: (cellValue: string) => string;
+    style: (cellValue: string, ...effects: string[]) => string;
+};
+export type TableFormatter = (this: TableFormatterContext, ...args: Parameters<TtyTable.Formatter>) => ReturnType<TtyTable.Formatter>;
+export type TableOptions = TtyTable.Options & {
+    showHeader?: boolean;
+};
+export type TableRow = Record<string, unknown> | unknown[];
+export declare const formatLabel: (value: string) => string;
+export declare const formatField: TableFormatter;
+export declare const createValueFormatter: (dateFormat: string) => TableFormatter;
+type TtyTable = (headers: TableColumn[], rows: TableRow[], options?: TableOptions) => {
+    render(): string;
+};
+export declare const renderTable: (headers: TableColumn[], rows: TableRow[], options?: TableOptions) => string;
+export {};

package/dist/helpers/table.js

@@ -0,0 +1,42 @@
+import { createRequire } from 'node:module';
+import { formatDateString } from './date-utils.js';
+export const formatLabel = (value) => value.replaceAll('_', ' ').replaceAll(/\b\w/g, (match) => match.toUpperCase());
+export const formatField = function (cellValue) {
+    if (cellValue === null || cellValue === undefined) {
+        return '';
+    }
+    if (typeof cellValue === 'string') {
+        return formatLabel(cellValue);
+    }
+    return formatLabel(String(cellValue));
+};
+export const createValueFormatter = (dateFormat) => function (cellValue) {
+    if (cellValue === null || cellValue === undefined) {
+        return '';
+    }
+    if (typeof cellValue === 'string') {
+        const formattedDate = formatDateString(cellValue, dateFormat);
+        if (formattedDate) {
+            return this.style(String(formattedDate), 'magenta');
+        }
+        return cellValue;
+    }
+    if (typeof cellValue === 'number') {
+        return this.style(String(cellValue), 'blue');
+    }
+    if (typeof cellValue === 'boolean') {
+        return cellValue ? this.style(String('✔︎'), 'green', 'bold') : this.style(String('×'), 'red', 'bold');
+    }
+    return this.style(JSON.stringify(cellValue), 'yellow');
+};
+const require = createRequire(import.meta.url);
+const ttyTable = require('tty-table');
+export const renderTable = (headers, rows, options) => ttyTable(headers.map((header) => ({
+    alias: header.alias ?? formatLabel(header.value),
+    align: 'left',
+    headerAlign: 'left',
+    ...header,
+})), rows, {
+    compact: true,
+    ...options,
+}).render();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/list-command.d.ts

@@ -0,0 +1,49 @@
+import type { ApiFlags } from './base-command.js';
+import { type TableColumn, type TableRow } from './helpers/table.js';
+import { PaginatedCommand } from './paginated-command.js';
+type ListCommandFlags = ApiFlags & {
+    'id-in'?: string;
+    'name-contains'?: string;
+    page?: number;
+    'page-size'?: number;
+    sort?: string;
+};
+type ListOutputFlags = ListCommandFlags & {
+    'date-format': string;
+    plain?: boolean;
+    table?: boolean;
+};
+type TableColumnInput = string | TableColumn;
+export declare abstract class ListCommand<TRaw extends TableRow = TableRow, TOutput extends TableRow = TRaw> extends PaginatedCommand {
+    static baseFlags: {
+        'id-in': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'name-contains': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        page: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'page-size': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'date-format': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        header: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        hostname: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        plain: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        table: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected abstract listPath: string;
+    protected abstract tableAttrs: TableColumnInput[];
+    protected fetchListResults<T>(options: {
+        flags: ListCommandFlags;
+        params?: Record<string, number | string | undefined>;
+        path: string;
+    }): Promise<T[]>;
+    protected listParams(flags: ListCommandFlags): Record<string, number | string | undefined>;
+    protected abstract plainTemplate(item: TOutput): null | string | undefined;
+    protected renderListOutput(options: {
+        flags: ListOutputFlags;
+        results: TOutput[];
+    }): void;
+    run(): Promise<TOutput[]>;
+    protected shouldAutoPaginate(flags: ListCommandFlags): boolean;
+    protected transformResult(result: TRaw): TOutput;
+    protected transformResults(results: TRaw[]): TOutput[];
+}
+export {};