@commercelayer/cli-core 5.0.0-oclif3.1 → 5.0.0-oclif3.10

package/lib/index.d.mts

@@ -0,0 +1,593 @@
+import { Command, Help, Interfaces, CommandHelp } from '@oclif/core';
+import { FlagInput } from '@oclif/core/lib/interfaces/parser';
+import chalk from 'chalk';
+import { Config as Config$1 } from '@oclif/core/lib/interfaces';
+
+declare const rawRequest: (config: {
+    baseUrl: string;
+    resource: string;
+    accessToken: string;
+    operation: Operation;
+}, data: any, id?: string) => Promise<any>;
+declare const readDataFile: (file: string) => any;
+declare enum Operation {
+    Create = "POST",
+    Update = "PATCH"
+}
+
+declare const denormalize: (response: any) => any;
+
+type Method = 'GET' | 'PATCH' | 'POST' | 'PUT' | 'DELETE';
+
+type ApiMode = 'test' | 'live';
+type ApiType = 'core' | 'provisioning' | 'metrics' | 'auth';
+
+/** Build base URL */
+declare const baseURL: (api?: ApiType, slug?: string, domain?: string) => string;
+/** Extract domain name from URL */
+declare const extractDomain: (baseUrl: string) => string | undefined;
+/** Decode API execution mode */
+declare const execMode: (liveFlag: string | boolean | undefined) => ApiMode;
+declare const humanizeResource: (type: string) => string;
+
+declare const isResourceCacheable: (resource?: string, method?: Method) => boolean;
+type DelayOptions = {
+    environment?: ApiMode;
+    parallelRequests?: number;
+    totalRequests?: number;
+    minimumDelay?: number;
+    securityDelay?: number;
+    resourceType?: string;
+    method?: Method;
+};
+declare const liveEnvironment: (env: ApiMode) => boolean;
+declare const requestRateLimitDelay: (options?: DelayOptions) => number;
+
+declare const request: {
+    raw: (config: {
+        baseUrl: string;
+        resource: string;
+        accessToken: string;
+        operation: Operation;
+    }, data: any, id?: string | undefined) => Promise<any>;
+    readDataFile: (file: string) => any;
+    rateLimitDelay: (options?: DelayOptions) => number;
+};
+declare const response: {
+    denormalize: (response: any) => any;
+};
+
+type api$1_ApiMode = ApiMode;
+type api$1_ApiType = ApiType;
+type api$1_DelayOptions = DelayOptions;
+type api$1_Operation = Operation;
+declare const api$1_Operation: typeof Operation;
+declare const api$1_baseURL: typeof baseURL;
+declare const api$1_execMode: typeof execMode;
+declare const api$1_extractDomain: typeof extractDomain;
+declare const api$1_humanizeResource: typeof humanizeResource;
+declare const api$1_isResourceCacheable: typeof isResourceCacheable;
+declare const api$1_liveEnvironment: typeof liveEnvironment;
+declare const api$1_request: typeof request;
+declare const api$1_requestRateLimitDelay: typeof requestRateLimitDelay;
+declare const api$1_response: typeof response;
+declare namespace api$1 {
+  export { type api$1_ApiMode as ApiMode, type api$1_ApiType as ApiType, type api$1_DelayOptions as DelayOptions, api$1_Operation as Operation, api$1_baseURL as baseURL, api$1_execMode as execMode, api$1_extractDomain as extractDomain, api$1_humanizeResource as humanizeResource, api$1_isResourceCacheable as isResourceCacheable, api$1_liveEnvironment as liveEnvironment, api$1_request as request, readDataFile as requestDataFile, api$1_requestRateLimitDelay as requestRateLimitDelay, rawRequest as requestRaw, api$1_response as response, denormalize as responseDenormalize };
+}
+
+type AuthScope = string | string[];
+type AccessToken = {
+    accessToken: string;
+    tokenType: 'bearer' | 'Bearer';
+    expiresIn: number;
+    expires: Date;
+    scope: AuthScope;
+    createdAt: number;
+    error?: string;
+    errorDescription?: string;
+};
+type AccessTokenInfo = {
+    organization?: {
+        id: string;
+        slug: string;
+    };
+    application: {
+        id: string;
+        kind: 'integration' | 'sales_channel' | 'user';
+        public: boolean;
+    };
+    test: boolean;
+    exp?: number;
+    rand?: number;
+    owner?: {
+        id: string;
+        type: 'Customer' | 'User';
+    };
+    market?: {
+        id: string[];
+        price_list_id: string;
+        stock_location_ids?: string[];
+        geocoder_id?: string;
+        allows_external_prices: boolean;
+    };
+    scope?: AuthScope;
+    user?: {
+        id: string;
+    };
+};
+type CustomToken = {
+    accessToken: string;
+    info: AccessTokenInfo;
+    expMinutes: number;
+};
+/** Decode a Commerce Layer access token */
+declare const decodeAccessToken: (accessToken: string) => AccessTokenInfo;
+/** generate a custom access token */
+declare const generateAccessToken: (token: AccessTokenInfo, sharedSecret: string, minutes: number) => CustomToken;
+declare const getAccessToken: (auth: AppAuth) => Promise<AccessToken>;
+declare const revokeAccessToken: (app: AppAuth, token: string) => Promise<void>;
+declare const isAccessTokenExpiring: (tokenData: AccessToken) => boolean;
+declare const getTokenEnvironment: (token: string | AccessTokenInfo) => ApiMode;
+
+type token_AccessToken = AccessToken;
+type token_AccessTokenInfo = AccessTokenInfo;
+type token_AuthScope = AuthScope;
+type token_CustomToken = CustomToken;
+declare const token_decodeAccessToken: typeof decodeAccessToken;
+declare const token_generateAccessToken: typeof generateAccessToken;
+declare const token_getAccessToken: typeof getAccessToken;
+declare const token_getTokenEnvironment: typeof getTokenEnvironment;
+declare const token_isAccessTokenExpiring: typeof isAccessTokenExpiring;
+declare const token_revokeAccessToken: typeof revokeAccessToken;
+declare namespace token {
+  export { type token_AccessToken as AccessToken, type token_AccessTokenInfo as AccessTokenInfo, type token_AuthScope as AuthScope, type token_CustomToken as CustomToken, token_decodeAccessToken as decodeAccessToken, token_generateAccessToken as generateAccessToken, token_getAccessToken as getAccessToken, token_getTokenEnvironment as getTokenEnvironment, token_isAccessTokenExpiring as isAccessTokenExpiring, token_revokeAccessToken as revokeAccessToken };
+}
+
+interface AppKey {
+    key: string;
+    mode: ApiMode;
+    id?: string;
+    alias?: string;
+}
+interface AppAuth {
+    slug?: string;
+    domain?: string;
+    clientId: string;
+    clientSecret?: string;
+    scope?: AuthScope;
+    email?: string;
+    password?: string;
+    api?: ApiType;
+}
+interface AppInfo extends AppKey, AppAuth {
+    organization?: string;
+    kind: string;
+    name: string;
+    baseUrl?: string;
+}
+
+/** Build application key */
+declare const appKey: () => string;
+/** Check application key */
+declare const appKeyValid: (appKey: AppKey) => boolean;
+/** Check if two application keys are equal */
+declare const appKeyMatch: (app1?: AppKey, app2?: AppKey) => boolean;
+declare const arrayScope: (scope?: AuthScope) => string[];
+declare const isProvisioningApp: (app: AppAuth) => boolean;
+
+type application_AppAuth = AppAuth;
+type application_AppInfo = AppInfo;
+type application_AppKey = AppKey;
+declare const application_appKey: typeof appKey;
+declare const application_appKeyMatch: typeof appKeyMatch;
+declare const application_appKeyValid: typeof appKeyValid;
+declare const application_arrayScope: typeof arrayScope;
+declare const application_isProvisioningApp: typeof isProvisioningApp;
+declare namespace application {
+  export { type application_AppAuth as AppAuth, type application_AppInfo as AppInfo, type application_AppKey as AppKey, application_appKey as appKey, application_appKeyMatch as appKeyMatch, application_appKeyValid as appKeyValid, application_arrayScope as arrayScope, application_isProvisioningApp as isProvisioningApp };
+}
+
+type ApiConfig = {
+    default_domain: string;
+    default_app_domain: string;
+    default_stg_domain: string;
+    token_expiration_mins: number;
+    token_encoding_algorithm: string;
+    requests_max_num_burst: number;
+    requests_max_num_burst_cacheable: number;
+    requests_max_num_burst_test: number;
+    requests_max_num_burst_test_cacheable: number;
+    requests_max_secs_burst: number;
+    requests_max_num_avg: number;
+    requests_max_num_avg_cacheable: number;
+    requests_max_num_avg_test: number;
+    requests_max_num_avg_test_cacheable: number;
+    requests_max_secs_avg: number;
+    requests_max_num_oauth: number;
+    requests_max_secs_oauth: number;
+    page_max_size: number;
+    page_default_size: number;
+};
+type ApplicationConfig = {
+    kinds: readonly string[];
+    login_scopes: readonly string[];
+};
+type ImportsConfig = {
+    max_size: number;
+    statuses: readonly string[];
+    types: readonly string[];
+    max_queue_length: number;
+    attachment_expiration: number;
+};
+type ExportsConfig = {
+    max_size: number;
+    statuses: readonly string[];
+    types: readonly string[];
+    max_queue_length: number;
+    attachment_expiration: number;
+};
+type CleanupsConfig = {
+    max_size: number;
+    statuses: readonly string[];
+    types: readonly string[];
+    max_queue_length: number;
+};
+type WebhooksConfig = {
+    retry_number: number;
+};
+type CliConfig = {
+    applications: readonly string[];
+};
+type DocConfig = {
+    core: string;
+    core_api_reference: string;
+    core_how_tos: string;
+    core_raste_limits: string;
+    core_filtering_data: string;
+    metrics: string;
+    metrics_api_reference: string;
+    provisioning: string;
+    provisioning_api_reference: string;
+    imports_resources: string;
+    exports_resources: string;
+    cleanups_resources: string;
+    webhooks_events: string;
+    tags_resources: string;
+};
+type TagsConfig = {
+    max_resource_tags: number;
+    taggable_resources: readonly string[];
+    tag_name_max_length: number;
+    tag_name_pattern: RegExp;
+};
+type ProvisioningConfig = {
+    default_subdomain: string;
+    scope: string;
+    applications: readonly string[];
+};
+type Config = {
+    api: ApiConfig;
+    application: ApplicationConfig;
+    imports: ImportsConfig;
+    exports: ExportsConfig;
+    cleanups: CleanupsConfig;
+    webhooks: WebhooksConfig;
+    cli: CliConfig;
+    doc: DocConfig;
+    tags: TagsConfig;
+    provisioning: ProvisioningConfig;
+};
+declare const config: Config;
+
+/** Copy command flags excluding a subset */
+declare const commandFlags: <T extends object>(flags: T, exclude?: string[]) => T;
+declare const allFlags: (command: Command.Class) => FlagInput;
+
+type KeyVal = Record<string, string | number | boolean | undefined | null>;
+type KeyValString = Record<string, string>;
+type KeyValArray = Record<string, string[]>;
+type KeyValRel = Record<string, {
+    readonly type: string;
+    readonly id: string;
+}>;
+type KeyValObj = Record<string, any>;
+type KeyValSort = Record<string, 'asc' | 'desc'>;
+type ResAttributes = KeyValObj;
+declare const fixValueType: (val: string) => string | number | boolean | null | undefined;
+declare const findLongStringFlag: (args: string[], name: string) => {
+    value: string;
+    index: number;
+    single: boolean;
+} | undefined;
+declare const fixDashedFlagValue: (argv: string[], flag: any, name?: string, parsed?: any) => string[];
+
+type command_KeyVal = KeyVal;
+type command_KeyValArray = KeyValArray;
+type command_KeyValObj = KeyValObj;
+type command_KeyValRel = KeyValRel;
+type command_KeyValSort = KeyValSort;
+type command_KeyValString = KeyValString;
+type command_ResAttributes = ResAttributes;
+declare const command_allFlags: typeof allFlags;
+declare const command_commandFlags: typeof commandFlags;
+declare const command_findLongStringFlag: typeof findLongStringFlag;
+declare const command_fixDashedFlagValue: typeof fixDashedFlagValue;
+declare const command_fixValueType: typeof fixValueType;
+declare namespace command {
+  export { type command_KeyVal as KeyVal, type command_KeyValArray as KeyValArray, type command_KeyValObj as KeyValObj, type command_KeyValRel as KeyValRel, type command_KeyValSort as KeyValSort, type command_KeyValString as KeyValString, type command_ResAttributes as ResAttributes, command_allFlags as allFlags, command_commandFlags as commandFlags, command_findLongStringFlag as findLongStringFlag, command_fixDashedFlagValue as fixDashedFlagValue, command_fixValueType as fixValueType };
+}
+
+/** Print a formatted object */
+declare const printObject: (obj: any, options?: {
+    color?: boolean;
+    sort?: boolean;
+    width?: number;
+}) => string;
+/** Print object in JSON format */
+declare const printJSON: (obj: any, options?: {
+    unformatted?: boolean;
+    tabSize?: number;
+}) => string;
+/** Print object in CSV format */
+declare const printCSV: (obj: object[], flags?: any) => string;
+/** Center a string in the given width space */
+declare const center: (str: string, width: number) => string;
+/** Compute longest string in a list of strings */
+declare const maxLength: (values: any[], field: string) => number;
+/** Clean ISO string date */
+declare const cleanDate: (date: string) => string;
+/** Localized string date */
+declare const localeDate: (date: string) => string;
+/** Format aoutput */
+declare const formatOutput: (output: any, flags?: any, { color }?: {
+    color?: boolean | undefined;
+}) => string;
+/** Format error message */
+declare const formatError: (error: any, flags?: any) => string;
+
+declare const output_center: typeof center;
+declare const output_cleanDate: typeof cleanDate;
+declare const output_formatError: typeof formatError;
+declare const output_formatOutput: typeof formatOutput;
+declare const output_localeDate: typeof localeDate;
+declare const output_maxLength: typeof maxLength;
+declare const output_printCSV: typeof printCSV;
+declare const output_printJSON: typeof printJSON;
+declare const output_printObject: typeof printObject;
+declare namespace output {
+  export { output_center as center, output_cleanDate as cleanDate, output_formatError as formatError, output_formatOutput as formatOutput, output_localeDate as localeDate, output_maxLength as maxLength, output_printCSV as printCSV, output_printJSON as printJSON, output_printObject as printObject };
+}
+
+declare const reset: chalk.Chalk;
+declare const visible: chalk.Chalk;
+declare const hidden: chalk.Chalk;
+declare const red: chalk.Chalk;
+declare const redBright: chalk.Chalk;
+declare const green: chalk.Chalk;
+declare const greenBright: chalk.Chalk;
+declare const yellow: chalk.Chalk;
+declare const yellowBright: chalk.Chalk;
+declare const blue: chalk.Chalk;
+declare const blueBright: chalk.Chalk;
+declare const white: chalk.Chalk;
+declare const whiteBright: chalk.Chalk;
+declare const black: chalk.Chalk;
+declare const blackBright: chalk.Chalk;
+declare const grey: chalk.Chalk;
+declare const cyan: chalk.Chalk;
+declare const cyanBright: chalk.Chalk;
+declare const magenta: chalk.Chalk;
+declare const magentaBright: chalk.Chalk;
+declare const bold: chalk.Chalk;
+declare const dim: chalk.Chalk;
+declare const underline: chalk.Chalk;
+declare const italic: chalk.Chalk;
+declare const bg: {
+    white: chalk.Chalk;
+    whiteBright: chalk.Chalk;
+    black: chalk.Chalk;
+    blackBright: chalk.Chalk;
+    grey: chalk.Chalk;
+    red: chalk.Chalk;
+    redBright: chalk.Chalk;
+    green: chalk.Chalk;
+    greenBright: chalk.Chalk;
+    yellow: chalk.Chalk;
+    yellowBright: chalk.Chalk;
+    blue: chalk.Chalk;
+    blueBright: chalk.Chalk;
+    magenta: chalk.Chalk;
+    magentaBright: chalk.Chalk;
+    cyan: chalk.Chalk;
+    cyanBright: chalk.Chalk;
+};
+declare const style: {
+    organization: chalk.Chalk;
+    application: chalk.Chalk;
+    slug: chalk.Chalk;
+    id: chalk.Chalk;
+    token: chalk.Chalk;
+    resource: chalk.Chalk;
+    attribute: chalk.Chalk;
+    trigger: chalk.Chalk;
+    kind: chalk.Chalk;
+    live: chalk.Chalk;
+    test: chalk.Chalk;
+    execMode: (mode: ApiMode) => chalk.Chalk;
+    success: chalk.Chalk;
+    warning: chalk.Chalk;
+    error: chalk.Chalk;
+    arg: chalk.Chalk;
+    flag: chalk.Chalk;
+    command: chalk.Chalk;
+    value: chalk.Chalk;
+    alias: chalk.Chalk;
+    plugin: chalk.Chalk;
+    title: chalk.Chalk;
+    path: chalk.Chalk;
+    datetime: chalk.Chalk;
+    number: chalk.Chalk;
+};
+declare const type: {
+    datetime: chalk.Chalk;
+    number: chalk.Chalk;
+    path: chalk.Chalk;
+};
+declare const api: {
+    organization: chalk.Chalk;
+    application: chalk.Chalk;
+    slug: chalk.Chalk;
+    id: chalk.Chalk;
+    token: chalk.Chalk;
+    resource: chalk.Chalk;
+    attribute: chalk.Chalk;
+    trigger: chalk.Chalk;
+    kind: chalk.Chalk;
+    live: chalk.Chalk;
+    test: chalk.Chalk;
+};
+declare const msg: {
+    success: chalk.Chalk;
+    warning: chalk.Chalk;
+    error: chalk.Chalk;
+};
+declare const cli: {
+    arg: chalk.Chalk;
+    flag: chalk.Chalk;
+    command: chalk.Chalk;
+    value: chalk.Chalk;
+    alias: chalk.Chalk;
+    plugin: chalk.Chalk;
+};
+declare const table: {
+    header: chalk.Chalk;
+    key: chalk.Chalk;
+};
+
+declare const color_api: typeof api;
+declare const color_bg: typeof bg;
+declare const color_black: typeof black;
+declare const color_blackBright: typeof blackBright;
+declare const color_blue: typeof blue;
+declare const color_blueBright: typeof blueBright;
+declare const color_bold: typeof bold;
+declare const color_cli: typeof cli;
+declare const color_cyan: typeof cyan;
+declare const color_cyanBright: typeof cyanBright;
+declare const color_dim: typeof dim;
+declare const color_green: typeof green;
+declare const color_greenBright: typeof greenBright;
+declare const color_grey: typeof grey;
+declare const color_hidden: typeof hidden;
+declare const color_italic: typeof italic;
+declare const color_magenta: typeof magenta;
+declare const color_magentaBright: typeof magentaBright;
+declare const color_msg: typeof msg;
+declare const color_red: typeof red;
+declare const color_redBright: typeof redBright;
+declare const color_reset: typeof reset;
+declare const color_style: typeof style;
+declare const color_table: typeof table;
+declare const color_type: typeof type;
+declare const color_underline: typeof underline;
+declare const color_visible: typeof visible;
+declare const color_white: typeof white;
+declare const color_whiteBright: typeof whiteBright;
+declare const color_yellow: typeof yellow;
+declare const color_yellowBright: typeof yellowBright;
+declare namespace color {
+  export { color_api as api, color_bg as bg, color_black as black, color_blackBright as blackBright, color_blue as blue, color_blueBright as blueBright, color_bold as bold, color_cli as cli, color_cyan as cyan, color_cyanBright as cyanBright, color_dim as dim, color_green as green, color_greenBright as greenBright, color_grey as grey, color_hidden as hidden, color_italic as italic, color_magenta as magenta, color_magentaBright as magentaBright, color_msg as msg, color_red as red, color_redBright as redBright, color_reset as reset, color_style as style, color_table as table, color_type as type, color_underline as underline, color_visible as visible, color_white as white, color_whiteBright as whiteBright, color_yellow as yellow, color_yellowBright as yellowBright };
+}
+
+interface Package {
+    name: string;
+    version: string;
+    description: string;
+}
+declare const checkUpdate: (pkg: Package) => void;
+
+type update_Package = Package;
+declare const update_checkUpdate: typeof checkUpdate;
+declare namespace update {
+  export { type update_Package as Package, update_checkUpdate as checkUpdate };
+}
+
+/** Await ms milliseconds */
+declare const sleep: (ms: number) => Promise<void>;
+declare const resetConsole: () => void;
+declare const log: (message?: string, ...args: unknown[]) => void;
+declare const specialFolder: (filePath: string, createIfNotExists?: boolean) => string;
+declare const generateGroupUID: () => string;
+declare const userAgent: (config: Config$1) => string;
+
+declare const util_generateGroupUID: typeof generateGroupUID;
+declare const util_log: typeof log;
+declare const util_resetConsole: typeof resetConsole;
+declare const util_sleep: typeof sleep;
+declare const util_specialFolder: typeof specialFolder;
+declare const util_userAgent: typeof userAgent;
+declare namespace util {
+  export { util_generateGroupUID as generateGroupUID, util_log as log, util_resetConsole as resetConsole, util_sleep as sleep, util_specialFolder as specialFolder, util_userAgent as userAgent };
+}
+
+declare class CLICommandHelp extends CommandHelp {
+    examples(examples: Command.Example[] | undefined | string): string | undefined;
+}
+declare class CLIBaseHelp extends Help {
+    showHelp(args: string[]): Promise<void>;
+    showRootHelp(): Promise<void>;
+    showTopicHelp(topic: Interfaces.Topic): Promise<void>;
+    showCommandHelp(command: Command.Loadable): Promise<void>;
+    formatRoot(): string;
+    formatTopic(topic: Interfaces.Topic): string;
+    formatTopics(topics: Interfaces.Topic[]): string;
+    formatCommands(commands: Command.Loadable[]): string;
+    formatCommand(command: Command.Loadable): string;
+    getCommandHelpClass(command: Command.Loadable): CLICommandHelp;
+}
+
+declare const downloadSchema: (version?: string) => Promise<any>;
+
+declare namespace schema {
+  export { downloadSchema as download };
+}
+
+declare const symbols: Record<string, Record<string, string>>;
+
+declare const symbol_symbols: typeof symbols;
+declare namespace symbol {
+  export { symbol_symbols as symbols };
+}
+
+declare const capitalize: (str: string | undefined) => string | undefined;
+declare const pluralize: (str: string, plural?: string | undefined) => string;
+declare const singularize: (str: string, singular?: string | undefined) => string;
+declare const camelize: (str: string, lowFirstLetter?: boolean | undefined) => string;
+
+declare const text_camelize: typeof camelize;
+declare const text_capitalize: typeof capitalize;
+declare const text_pluralize: typeof pluralize;
+declare const text_singularize: typeof singularize;
+declare const text_symbols: typeof symbols;
+declare namespace text {
+  export { text_camelize as camelize, text_capitalize as capitalize, text_pluralize as pluralize, text_singularize as singularize, text_symbols as symbols };
+}
+
+declare const documentation: string;
+interface Filter extends Record<string, unknown> {
+    predicate: string;
+    description: string;
+}
+declare const filterList: () => string[];
+declare const filterAvailable: (filter: string) => boolean;
+declare const applyFilter: (predicate: string, ...fields: string[]) => string;
+declare const filters: () => Filter[];
+
+type filter_Filter = Filter;
+declare const filter_documentation: typeof documentation;
+declare const filter_filters: typeof filters;
+declare namespace filter {
+  export { type filter_Filter as Filter, applyFilter as apply, filterAvailable as available, filter_documentation as documentation, filter_filters as filters, filterList as list };
+}
+
+export { type AccessToken, type AccessTokenInfo, type ApiMode, type ApiType, type AppAuth, type AppInfo, type AppKey, type AuthScope, type CustomToken, type KeyVal, type KeyValArray, type KeyValObj, type KeyValRel, type KeyValSort, type KeyValString, type ResAttributes, api$1 as clApi, application as clApplication, color as clColor, command as clCommand, config as clConfig, filter as clFilter, CLIBaseHelp as clHelp, output as clOutput, schema as clSchema, symbol as clSymbol, text as clText, token as clToken, update as clUpdate, util as clUtil };