@hubspot/cli 8.0.10-experimental.5 → 8.0.10-experimental.6

package/lib/prompts/selectAppPrompt.js

@@ -1,37 +0,0 @@
-import { uiLogger } from '../ui/logger.js';
-import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
-import { debugError } from '../errorHandlers/index.js';
-import { lib } from '../../lang/en.js';
-import { listPrompt } from '../prompts/promptUtils.js';
-export async function selectAppPrompt(accountId, appId) {
-    let availableApps = [];
-    try {
-        const appsResponse = await fetchPublicAppsForPortal(accountId);
-        if (appsResponse.data.results) {
-            availableApps = appsResponse.data.results;
-        }
-    }
-    catch (err) {
-        debugError(err);
-    }
-    if (availableApps.length === 0) {
-        uiLogger.error(lib.prompts.selectAppPrompt.errors.noApps);
-        return null;
-    }
-    if (appId) {
-        const targetApp = availableApps.find(app => app.id === appId);
-        if (targetApp) {
-            return targetApp;
-        }
-        else {
-            uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
-        }
-    }
-    const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
-        choices: availableApps.map(app => ({
-            name: `${app.name} (${app.id})`,
-            value: app,
-        })),
-    });
-    return appPromptValue;
-}

package/lib/prompts/selectHubDBTablePrompt.d.ts

@@ -1,12 +0,0 @@
-export declare function selectHubDBTablePrompt({ accountId, options, skipDestPrompt, }: {
-    accountId: number;
-    options: {
-        tableId?: number;
-        dest?: string;
-    };
-    skipDestPrompt?: boolean;
-}): Promise<{
-    tableId: any;
-} & {
-    dest: any;
-}>;

package/lib/prompts/selectHubDBTablePrompt.js

@@ -1,66 +0,0 @@
-import fs from 'fs';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { debugError } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
-import { PromptExitError } from '../errors/PromptExitError.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-async function fetchHubDBOptions(accountId) {
-    try {
-        const { data: { results: tables }, } = await fetchTables(accountId);
-        if (tables.length === 0) {
-            uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
-            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
-        }
-        return tables;
-    }
-    catch (error) {
-        if (error instanceof PromptExitError) {
-            throw error;
-        }
-        debugError(error, { accountId });
-        uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
-        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
-    }
-}
-export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
-    const hubdbTables = await fetchHubDBOptions(accountId);
-    const id = options.tableId?.toString();
-    const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
-    return promptUser([
-        {
-            name: 'tableId',
-            message: lib.prompts.selectHubDBTablePrompt.selectTable,
-            when: !id && !isValidTable,
-            type: 'list',
-            choices: hubdbTables.map(table => {
-                return {
-                    name: `${table.label} (${table.id})`,
-                    value: table.id,
-                };
-            }),
-        },
-        {
-            name: 'dest',
-            message: lib.prompts.selectHubDBTablePrompt.enterDest,
-            when: !options.dest && !skipDestPrompt,
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.selectHubDBTablePrompt.errors.destRequired;
-                }
-                if (fs.existsSync(input)) {
-                    return lib.prompts.selectHubDBTablePrompt.errors.invalidDest;
-                }
-                if (!isValidPath(input)) {
-                    return lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters;
-                }
-                return true;
-            },
-            filter: (input) => {
-                return untildify(input);
-            },
-        },
-    ]);
-}

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -1,27 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects.js';
-export type SelectProjectTemplatePromptResponse = {
-    projectTemplate?: ProjectTemplate;
-    componentTemplates?: ComponentTemplate[];
-};
-type SelectProjectTemplatePromptResponseProjectTemplate = {
-    projectTemplate: ProjectTemplate;
-    componentTemplates: undefined;
-};
-type SelectProjectTemplatePromptResponseComponentTemplates = {
-    projectTemplate?: undefined;
-    componentTemplates?: ComponentTemplate[];
-};
-export type ProjectNameAndDestPromptResponse = {
-    name: string;
-    dest: string;
-};
-export type PromptOptionsArg = {
-    name?: string;
-    dest?: string;
-    template?: string;
-    features?: string[];
-};
-export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<SelectProjectTemplatePromptResponseProjectTemplate>;
-export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: (ComponentTemplateChoice | Separator)[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
-export {};

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -1,75 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
-    return projectTemplates.find(t => t.name === templateNameOrLabel || t.label === templateNameOrLabel);
-}
-export async function selectProjectTemplatePrompt(promptOptions, projectTemplates, componentTemplates) {
-    const createProjectFromTemplate = !!projectTemplates && projectTemplates.length > 0;
-    const createProjectFromComponents = Array.isArray(componentTemplates) && componentTemplates?.length > 0;
-    const selectedComponents = [];
-    if (createProjectFromComponents && promptOptions.features) {
-        componentTemplates.forEach(template => {
-            if (template instanceof Separator || !template.value) {
-                return;
-            }
-            if (promptOptions.features?.includes(template.value.cliSelector || template.value.type)) {
-                if (template.disabled) {
-                    throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
-                }
-                selectedComponents.push(template.value);
-            }
-        });
-    }
-    const providedTemplateIsValid = createProjectFromTemplate &&
-        !!promptOptions.template &&
-        !!findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
-    const result = await promptUser([
-        {
-            name: 'projectTemplate',
-            message: () => {
-                return promptOptions.template && !providedTemplateIsValid
-                    ? lib.prompts.selectProjectTemplatePrompt.errors.invalidTemplate(promptOptions.template)
-                    : lib.prompts.selectProjectTemplatePrompt.selectTemplate;
-            },
-            when: createProjectFromTemplate && !providedTemplateIsValid,
-            type: 'list',
-            choices: createProjectFromTemplate
-                ? projectTemplates.map(template => {
-                    return {
-                        name: template.label,
-                        value: template,
-                    };
-                })
-                : undefined,
-        },
-        {
-            name: 'componentTemplates',
-            message: lib.prompts.selectProjectTemplatePrompt.features,
-            when: !promptOptions.features &&
-                createProjectFromComponents &&
-                selectedComponents.length === 0,
-            type: 'checkbox',
-            choices: componentTemplates,
-            loop: false,
-            pageSize: componentTemplates?.length,
-        },
-    ]);
-    if (result.componentTemplates?.length === 0) {
-        uiLogger.log(lib.projects.add.nothingAdded);
-    }
-    if (!result.componentTemplates) {
-        result.componentTemplates = selectedComponents;
-    }
-    if (providedTemplateIsValid) {
-        result.projectTemplate = findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
-    }
-    if (projectTemplates && projectTemplates.length > 0) {
-        if (!result.projectTemplate) {
-            throw new Error(lib.prompts.selectProjectTemplatePrompt.errors.projectTemplateRequired);
-        }
-        return result;
-    }
-    return result;
-}

package/lib/prompts/selectPublicAppForMigrationPrompt.d.ts

@@ -1,9 +0,0 @@
-type PublicAppPromptResponse = {
-    appId: number;
-};
-export declare function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp, }: {
-    accountId: number | null;
-    accountName: string;
-    isMigratingApp?: boolean;
-}): Promise<PublicAppPromptResponse>;
-export {};

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -1,68 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLine } from '../ui/index.js';
-import { logError } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
-import { PromptExitError } from '../errors/PromptExitError.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
-    if (!accountId) {
-        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
-        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
-    }
-    try {
-        const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
-        const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
-        if (!filteredPublicApps.length ||
-            (isMigratingApp &&
-                !filteredPublicApps.some(app => !app.preventProjectMigrations || !app.listingInfo))) {
-            uiLine();
-            if (isMigratingApp) {
-                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigrationMessage(accountName)}`);
-            }
-            else {
-                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
-            }
-            uiLine();
-            throw new PromptExitError(isMigratingApp
-                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
-                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
-        }
-        return filteredPublicApps;
-    }
-    catch (error) {
-        if (error instanceof PromptExitError) {
-            throw error;
-        }
-        logError(error, accountId ? { accountId } : undefined);
-        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
-        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
-    }
-}
-export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {
-    const publicApps = await fetchPublicAppOptions(accountId, accountName, isMigratingApp);
-    return promptUser([
-        {
-            name: 'appId',
-            message: isMigratingApp
-                ? lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdMigrate(accountName)
-                : lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdClone(accountName),
-            type: 'list',
-            choices: publicApps.map(app => {
-                const { preventProjectMigrations, listingInfo } = app;
-                if (isMigratingApp && preventProjectMigrations && listingInfo) {
-                    return {
-                        name: `${app.name} (${app.id})`,
-                        disabled: lib.prompts.selectPublicAppForMigrationPrompt.errors
-                            .cannotBeMigrated,
-                    };
-                }
-                return {
-                    name: `${app.name} (${app.id})`,
-                    value: app.id,
-                };
-            }),
-        },
-    ]);
-}

package/lib/prompts/setAsDefaultAccountPrompt.d.ts

@@ -1 +0,0 @@
-export declare function setAsDefaultAccountPrompt(accountName: string): Promise<boolean>;

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -1,26 +0,0 @@
-import { setConfigAccountAsDefault, getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-export async function setAsDefaultAccountPrompt(accountName) {
-    // Accounts for deprecated and new config
-    const defaultAccount = getConfigDefaultAccountIfExists();
-    const accounts = getAllConfigAccounts() || [];
-    const { setAsDefault } = await promptUser([
-        {
-            name: 'setAsDefault',
-            type: 'confirm',
-            when: accounts.length >= 1 && defaultAccount?.name !== accountName,
-            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
-        },
-    ]);
-    uiLogger.log('');
-    if (setAsDefault) {
-        setConfigAccountAsDefault(accountName);
-        uiLogger.success(lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount(accountName));
-    }
-    else if (defaultAccount) {
-        uiLogger.log(lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault(defaultAccount.name));
-    }
-    return setAsDefault;
-}

package/lib/prompts/uploadPrompt.d.ts

@@ -1,9 +0,0 @@
-type UploadPromptResponse = {
-    src: string;
-    dest: string;
-};
-export declare function uploadPrompt(promptOptions?: {
-    src?: string;
-    dest?: string;
-}): Promise<UploadPromptResponse>;
-export {};

package/lib/prompts/uploadPrompt.js

@@ -1,32 +0,0 @@
-import path from 'path';
-import { getCwd } from '@hubspot/local-dev-lib/path';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-export async function uploadPrompt(promptOptions = {}) {
-    return promptUser([
-        {
-            name: 'src',
-            message: lib.prompts.uploadPrompt.enterSrc,
-            when: !promptOptions.src,
-            default: '.',
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.uploadPrompt.errors.srcRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'dest',
-            message: lib.prompts.uploadPrompt.enterDest,
-            when: !promptOptions.dest,
-            default: path.basename(getCwd()),
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.uploadPrompt.errors.destRequired;
-                }
-                return true;
-            },
-        },
-    ]);
-}

package/lib/sandboxes.d.ts

@@ -1,14 +0,0 @@
-import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxAccountType } from '../types/Sandboxes.js';
-export declare const SANDBOX_TYPE_MAP: {
-    [key: string]: SandboxAccountType;
-};
-export declare const SANDBOX_TYPE_MAP_V2: {
-    readonly STANDARD_SANDBOX: "STANDARD";
-    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
-};
-export declare function getSandboxTypeAsString(accountType?: AccountType): string;
-export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
-export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
-export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -1,105 +0,0 @@
-import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
-import { uiLogger } from './ui/logger.js';
-import { lib } from '../lang/en.js';
-import { logError } from './errorHandlers/index.js';
-import { uiAccountDescription } from './ui/index.js';
-export const SANDBOX_TYPE_MAP = {
-    dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-};
-export const SANDBOX_TYPE_MAP_V2 = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
-};
-export function getSandboxTypeAsString(accountType) {
-    if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-        return 'development'; // Only place we're using this specific name
-    }
-    return 'standard';
-}
-export function getHasSandboxesByType(parentAccountConfig, type) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const accountsList = getAllConfigAccounts();
-    for (const portal of accountsList) {
-        if ((portal.parentAccountId !== null ||
-            portal.parentAccountId !== undefined) &&
-            portal.parentAccountId === parentPortalId &&
-            portal.accountType &&
-            portal.accountType === type) {
-            return true;
-        }
-    }
-    return false;
-}
-export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
-    const accountId = accountConfig.accountId;
-    if (!accountId) {
-        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
-    }
-    const { data: { usage }, } = await getSandboxUsageLimits(accountId);
-    if (!usage) {
-        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
-    }
-    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-        if (usage['DEVELOPER'].available === 0) {
-            const devSandboxLimit = usage['DEVELOPER'].limit;
-            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
-            if (hasDevelopmentSandboxes) {
-                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
-            }
-            else {
-                const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
-            }
-        }
-    }
-    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
-        if (usage['STANDARD'].available === 0) {
-            const standardSandboxLimit = usage['STANDARD'].limit;
-            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
-            if (hasStandardSandboxes) {
-                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
-            }
-            else {
-                const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
-            }
-        }
-    }
-}
-export function handleSandboxCreateError(err, env, name, accountId) {
-    if (isMissingScopeError(err)) {
-        uiLogger.error(lib.sandbox.create.failure.scopes.message);
-        const websiteOrigin = getHubSpotWebsiteOrigin(env);
-        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
-    }
-    else if (isSpecifiedError(err, {
-        statusCode: 403,
-        category: 'BANNED',
-        subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
-    })) {
-        uiLogger.log('');
-        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
-        uiLogger.log('');
-    }
-    else if (isSpecifiedError(err, {
-        statusCode: 403,
-        category: 'BANNED',
-        subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
-    })) {
-        uiLogger.log('');
-        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
-        uiLogger.log('');
-    }
-    else {
-        logError(err);
-    }
-    throw err;
-}

package/lib/schema.d.ts

@@ -1,3 +0,0 @@
-import { Schema } from '@hubspot/local-dev-lib/types/Schemas';
-export declare function logSchemas(schemas: Array<Schema>): void;
-export declare function listSchemas(accountId: number): Promise<void>;

package/lib/schema.js

@@ -1,27 +0,0 @@
-import chalk from 'chalk';
-import { table, getBorderCharacters } from 'table';
-import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
-import { uiLogger } from './ui/logger.js';
-export function logSchemas(schemas) {
-    const data = schemas
-        .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
-        .sort((a, b) => (a[1] > b[1] ? 1 : -1));
-    if (data.length === 0) {
-        uiLogger.log('No Schemas were found');
-        return;
-    }
-    data.unshift([
-        chalk.bold('Label'),
-        chalk.bold('Name'),
-        chalk.bold('objectTypeId'),
-    ]);
-    const tableConfig = {
-        singleLine: true,
-        border: getBorderCharacters('honeywell'),
-    };
-    uiLogger.log(table(data, tableConfig));
-}
-export async function listSchemas(accountId) {
-    const { data } = await fetchObjectSchemas(accountId);
-    logSchemas(data.results);
-}

package/lib/serverlessLogs.d.ts

@@ -1,4 +0,0 @@
-import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
-import { FunctionLog, GetFunctionLogsResponse } from '@hubspot/local-dev-lib/types/Functions';
-export declare function tailLogs(accountId: number, name: string, fetchLatest: () => HubSpotPromise<FunctionLog>, tailCall: (after?: string) => HubSpotPromise<GetFunctionLogsResponse>, compact?: boolean): Promise<void>;
-export declare function outputBuildLog(buildLogUrl: string): Promise<string>;