{
  "lib": {
    "trackUsage": {
      "invalidEvent": "Usage tracking event {{ eventName }} is not a valid event type.",
      "sendingEventAuthenticated": "Sending usage event to authenticated endpoint",
      "retryingEventUnauthenticated": "Failed to send the usage event as authenticated. Trying again as unauthenticated.",
      "sendingEventUnauthenticated": "Sending usage event to unauthenticated endpoint",
      "unauthenticatedSendFailed": "Failed to send usage event to unauthenticated endpoint"
    },
    "archive": {
      "extractZip": {
        "init": "Extracting project source...",
        "success": "Completed project source extraction.",
        "errors": {
          "write": "An error occurred writing temp project source.",
          "extract": "An error occurred extracting project source."
        }
      },
      "copySourceToDest": {
        "init": "Copying project source...",
        "sourceEmpty": "Project source is empty",
        "success": "Completed copying project source.",
        "error": "An error occurred copying project source to {{ dest }}."
      },
      "cleanupTempDir": {
        "error": "Failed to clean up temp dir: {{ tmpDir }}"
      }
    },
    "gitignore": {
      "errors": {
        "configIgnore": "Unable to determine if config file is properly ignored by git."
      }
    },
    "github": {
      "rateLimitError": "Github rate limit hit. Set the GITHUB_TOKEN env variable with your github PATH. This will increase the github api's rate limit.",
      "fetchFileFromRepository": {
        "fetching": "Fetching {{ path }}...",
        "errors": {
          "fetchFail": "An error occurred fetching JSON file."
        }
      },
      "fetchReleaseData": {
        "errors": {
          "fetchFail": "Failed fetching release data for {{ tag }} project."
        }
      },
      "downloadGithubRepoZip": {
        "fetching": "Fetching repository with name {{ repoPath }}...",
        "fetchingName": "Fetching {{ name }}...",
        "completed": "Completed project fetch.",
        "errors": {
          "fetchFail": "An error occurred fetching the project source."
        }
      },
      "cloneGithubRepo": {
        "success": "Your new {{ type }} has been created in {{ dest }}"
      },
      "downloadGithubRepoContents": {
        "downloading": "Downloading content piece: {{ contentPiecePath }} from {{ downloadUrl }} to {{ downloadPath }}",
        "errors": {
          "fetchFail": "Failed to fetch contents: {{ errorMessage }}"
        }
      },
      "listGitHubRepoContents": {
        "errors": {
          "fetchFail": "Failed to fetch contents: {{ errorMessage }}"
        }
      }
    },
    "hubdb": {
      "errors": {
        "invalidJsonPath": "The HubDB table file must be a '.json' file",
        "invalidJsonFile": "The '{{{ src }}' path is not a path to a file"
      }
    },
    "personalAccessKey": {
      "errors": {
        "accountNotFound": "Account with id {{ accountId }} does not exist.",
        "invalidPersonalAccessKey": "Error while retrieving new access token: {{ errorMessage }}",
        "invalidAuthType": "Error fetching access token: account {{ accountId }} uses an auth type other than personalaccesskey"
      }
    },
    "crm": {
      "importData": {
        "errors": {
          "fileNotFound": "The file {{ fileName }} does not exist",
          "notJson": "You must provide a JSON file for the import data request schema.",
          "noFiles": "You must provide at least one data file for the import data request schema."
        }
      }
    },
    "cms": {
      "modules": {
        "createModule": {
          "creatingModule": "Creating module at {{ path }}",
          "creatingPath": "Creating {{ path }}",
          "errors": {
            "pathExists": "The {{ path }} path already exists",
            "fileUpdateFailure": "There was a problem updating the modules files at {{ path }}: {{ errorMessage }}"
          }
        },
        "retrieveDefaultModule": {
          "errors": {
            "pathExists": "Folder already exists at \"{{ path }}\""
          }
        }
      },
      "functions": {
        "updateExistingConfig": {
          "unableToReadFile": "The file {{ configFilePath }} could not be read",
          "invalidJSON": "The file {{ configFilePath }} is not valid JSON",
          "couldNotUpdateFile": "The file {{ configFilePath }} could not be updated",
          "errors": {
            "configIsNotObjectError": "The existing {{ configFilePath }} is not an object",
            "endpointAreadyExistsError": "The endpoint {{ endpointPath }} already exists in {{ configFilePath }}"
          }
        },
        "createFunction": {
          "destPathAlreadyExists": "The {{ path }} path already exists",
          "createdDest": "Created {{ path }}",
          "failedToCreateFile": "The file {{ configFilePath }} could not be created",
          "createdFunctionFile": "Created {{ path }}",
          "createdConfigFile": "Created {{ path }}",
          "success": "A function for the endpoint '/_hcms/api/{{ endpointPath }}' has been created. Upload {{ folderName }} to try it out",
          "errors": {
            "nestedConfigError": "Cannot create a functions directory inside '{{ ancestorConfigPath }}'",
            "jsFileConflictError": "The JavaScript file at '{{ functionFilePath }}'' already exists"
          }
        }
      },
      "handleFieldsJs": {
        "convertFieldsJs": {
          "creating": "Creating child process with pid {{ pid }}",
          "terminating": "Child process with pid {{ pid }} has been terminated",
          "errors": {
            "errorConverting": "There was an error converting '{{ filePath }}'"
          }
        },
        "saveOutput": {
          "errors": {
            "saveFailed": "There was an error saving the json output of {{ path }}"
          }
        },
        "createTmpDirSync": {
          "errors": {
            "writeFailed": "An error occurred writing temporary project source."
          }
        },
        "cleanupTmpDirSync": {
          "errors": {
            "deleteFailed": "There was an error deleting the temporary project source"
          }
        }
      },
      "uploadFolder": {
        "uploadFolder": {
          "success": "Uploaded file \"{{ file}}\" to \"{{ destPath }}\"",
          "attempt": "Attempting to upload file \"{{ file }}\" to \"{{ destPath }}\"",
          "failed": "Uploading file \"{{ file }}\" to \"{{ destPath }}\" failed so scheduled retry",
          "retry": "Retrying to upload file \"{{ file }}\" to \"{{ destPath }}\"",
          "retryFailed": "Uploading file \"{{ file }}\" to \"{{ destPath }}\" failed"
        }
      },
      "templates": {
        "createTemplate": {
          "creatingFile": "Creating file at {{ path }}",
          "creatingPath": "Making {{ path }} if needed",
          "errors": {
            "pathExists": "The {{ path }} path already exists"
          }
        }
      },
      "processFieldsJs": {
        "converting": "Converting \"{{ src }}\" to \"{{ dest }}\".",
        "converted": "Finished converting \"{{ src }}\" to \"{{ dest }}\".",
        "errors": {
          "invalidMjsFile": ".mjs files are only supported when using Node 13.2.0+",
          "notFunction": "There was an error loading JS file \"{{ path }}\". Expected type \"Function\" but received type \"{{ returned }}\". Make sure that your default export is a function.",
          "notArray": "There was an error loading JS file \"{{ path }}\". Expected type \"Array\" but received type \"{{ returned }}\" . Make sure that your function returns an array"
        }
      },
      "watch": {
        "notifyOfThemePreview": "To preview this theme, visit: {{ previewUrl }}",
        "skipUnsupportedExtension": "Skipping {{ file }} due to unsupported extension",
        "skipIgnoreRule": "Skipping {{ file }} due to an ignore rule",
        "uploadAttempt": "Attempting to upload file \"{{ file }}\" to \"{{ dest }}\"",
        "uploadSuccess": "Uploaded file {{ file }} to {{ dest }}",
        "uploadFailed": "Uploading file {{ file }} to {{ dest }} failed",
        "uploadRetry": "Retrying to upload file \"{{ file }}\" to \"{{ dest }}\"",
        "deleteAttempt": "Attempting to delete file {{ remoteFilePath }}",
        "deleteAttemptWithType": "Attempting to delete {{ type }} {{ remoteFilePath }}",
        "deleteSuccess": "Deleted file {{ remoteFilePath }}",
        "deleteSuccessWithType": "Deleted {{ type }} {{ remoteFilePath }}",
        "deleteFailed": "Deleting file {{ remoteFilePath }} failed",
        "folderUploadSuccess": "Completed uploading files in {{ src }} to {{ dest }} in {{ accountId }}",
        "ready": "Watcher is ready and watching {{ src }}. Any changes detected will be automatically uploaded and overwrite the current version in the developer file system."
      }
    },
    "oauth": {
      "writeTokenInfo": "Updating Oauth2 token info for portalId: {{ portalId }}",
      "addOauthToAccountConfig": {
        "init": "Updating configuration",
        "success": "Configuration updated"
      }
    },
    "fileManager": {
      "uploadStarted": "Uploading files from \"{{ file }}\" to \"{{ destPath }}\" in the File Manager of account {{ accountId }}",
      "uploadSuccess": "Uploaded file \"{{ file }}\" to \"{{ destPath }}\"",
      "skippedExisting": "Skipped existing {{ filepath }}",
      "fetchingFiles": "Fetching {{ fileCount }} files from remote folder: {{ folderName }}",
      "fetchFolderStarted": "Fetching folder from \"{{ src }}\" to \"{{ path }}\" in the File Manager of account {{ accountId }}",
      "fetchFolderSuccess": "Completed fetch of folder \"{{ src }}\" to \"{{ dest }}\" from the File Manager",
      "fetchFileStarted": "Fetching file from \"{{ src }}\" to \"{{ dest }}\" in the File Manager of account {{ accountId }}",
      "fetchFileSuccess": "Completed fetch of file \"{{ src }}\" to \"{{ dest }}\" from the File Manager",
      "errors": {
        "uploadFailed": "Uploading file \"{{ file }}\" to \"{{ destPath }}\" failed",
        "archivedFile": "\"{{ src }} \" in the File Manager is an archived file. Try fetching again with the \"--include-archived\" flag",
        "hiddenFile": "\"{{ src }}\" in the File Manager is a hidden file."
      }
    },
    "fileMapper": {
      "skippedExisting": "Skipped existing {{ filepath }}",
      "wroteFolder": "Wrote folder {{ filepath }}",
      "completedFetch": "Completed fetch of file \"{{ src }}\"{{ version }} to \"{{ dest }}\" from the Design Manager",
      "folderFetch": "Fetched \"{{ src }}\" from account {{ accountId }} from the Design Manager successfully",
      "completedFolderFetch": "Completed fetch of folder \"{{ src }}\"{{ version }} to \"{{ dest }}\" from the Design Manager",
      "errors": {
        "invalidRequest": "Invalid request for file: {{ src }}",
        "invalidNode": "Invalid FileMapperNode: {{ json }}",
        "invalidFileType": "Invalid file type requested: {{ srcPath }}",
        "assetTimeout": "HubSpot assets are unavailable at the moment. Please wait a few minutes and try again.",
        "failedToFetchFile": "Failed fetch of file \"{{ src }}\" to \"{{ dest }}\" from the Design Manager",
        "failedToFetchFolder": "Failed fetch of folder \"{{ src }}\" to \"{{ dest }}\" from the Design Manager",
        "invalidFetchFolderRequest": "Invalid request for folder: \"{{ src }}\"",
        "incompleteFetch": "Not all files in folder \"{{ src }}\" were successfully fetched.  Re-run the last command to try again"
      }
    },
    "accountTypes": {
      "developmentSandbox": "dev sandbox",
      "standardSandbox": "standard sandbox",
      "developerTest": "test account",
      "appDeveloper": "dev account",
      "standard": "standard"
    }
  },
  "config": {
    "getDefaultConfigFilePath": {
      "error": "Attempted to get config file path, but no config file was found."
    },
    "getConfig": {
      "reading": "Reading config from {{ path }}",
      "error": "No config file found.",
      "errorWithPath": "No config file found at {{ path }}."
    },
    "validateConfig": {
      "missingAccounts": "No accounts found",
      "duplicateAccountIds": "Multiple accounts with accountId: {{ accountId }}",
      "duplicateAccountNames": "Multiple accounts with name: {{ accountName }}",
      "invalidAccountName": "Account name {{ accountName }} contains spaces"
    },
    "getConfigAccountById": {
      "error": "No account with id {{ accountId }} exists in config"
    },
    "getConfigAccountByName": {
      "error": "No account with name {{ accountName }} exists in config"
    },
    "getConfigDefaultAccount": {
      "fieldMissingError": "Attempted to get default account, but no default account was found in config",
      "accountMissingError": "Default account is set to {{ defaultAccount }}, but no account with that id exists in config"
    },
    "addConfigAccount": {
      "invalidAccount": "Attempting to add account, but account is invalid",
      "duplicateAccount": "Attempting to add account, but account with id {{ accountId }} already exists in config"
    },
    "updateConfigAccount": {
      "invalidAccount": "Attempting to update account {{ name }}, but account is invalid",
      "accountNotFound": "Attempting to update account with id {{ id }}, but that account was not found in config"
    },
    "setConfigAccountAsDefault": {
      "accountNotFound": "Attempted to set account with identifier {{ identifier }} as default, but that account was not found in config"
    },
    "renameConfigAccount": {
      "accountNotFound": "Attempted to rename account with name {{ currentName }}, but that account was not found in config",
      "duplicateAccount": "Attempted to rename account {{ currentName }} to {{ newName }}, but an account with that name already exists in config"
    },
    "removeAccountFromConfig": {
      "accountNotFound": "Attempted to remove account with id {{ accountId }}, but that account was not found in config"
    },
    "updateHttpTimeout": {
      "invalidTimeout": "HTTP timeout must be greater than {{ minTimeout }}. Received {{ timeout }}"
    },
    "updateDefaultCmsPublishMode": {
      "invalidCmsPublishMode": "Error updating config default CMS publish mode: CMS publish can only be set to 'draft' or 'publish'"
    },
    "getConfigAccountEnvironment": {
      "accountNotFound": "Attempted to get environment for account with identifier {{ identifier }}, but that account was not found in config"
    },
    "utils": {
      "handleConfigFileSystemError": {
        "configNotFoundError": "No config file found at {{ path }}.",
        "insufficientPermissionsError": "Insufficient permissions to access config file at {{ path }}"
      },
      "validateConfigAccount": {
        "missingAccount": "At least one account in config is missing data",
        "missingAuthType": "Account {{ accountId }} has no authType",
        "missingAccountId": "At least one account in config is missing accountId",
        "missingApiKey": "Account {{ accountId }} has authType of apikey but is missing the apiKey field",
        "missingAuth": "Account {{ accountId }} has authtype of oauth2 but is missing auth data",
        "missingPersonalAccessKey": "Account {{ accountId }} has authType of personalAccessKey but is missing the personalAccessKey field"
      },
      "getConfigPathEnvironmentVariables": {
        "invalidEnvironmentVariables": "USE_ENVIRONMENT_HUBSPOT_CONFIG and HUBSPOT_CONFIG_PATH cannot both be set simultaneously"
      },
      "parseConfig": {
        "error": "File could not be parsed. Confirm that your config file {{ configPath }} is valid YAML."
      },
      "buildConfigFromEnvironment": {
        "missingAccountId": "HUBSPOT_ACCOUNT_ID is required, but not currently set",
        "invalidAuthType": "Auth type is invalid. Use HUBSPOT_CLIENT_ID, HUBSPOT_CLIENT_SECRET, and HUBSPOT_REFRESH_TOKEN to authenticate with Oauth2, HUBSPOT_PERSONAL_ACCESS_KEY to authenticate with Personal Access Key, or API_KEY to authenticate with API Key."
      }
    },
    "defaultAccountOverride": {
      "getDefaultAccountOverrideAccountId": {
        "errorHeader": "Error in {{ hsAccountFile }}",
        "readFileError": "Error reading account override file."
      }
    },
    "updateAllowUsageTracking": {
      "invalidInput": "Unable to update allowUsageTracking. The value {{ isAllowed }} is invalid. The value must be a boolean."
    },
    "updateAllowAutoUpdates": {
      "invalidInput": "Unable to update allowAutoUpdates. The value {{ isEnabled }} is invalid. The value must be a boolean."
    },
    "updateAutoOpenBrowser": {
      "invalidInput": "Unable to update autoOpenBrowser. The value {{ isEnabled }} is invalid. The value must be a boolean."
    },
    "configFile": {
      "errorReading": "Config file could not be read: {{ configPath }}",
      "writeSuccess": "Successfully wrote updated config data to {{ configPath }}",
      "errorLoading": "A configuration file could not be found at {{ configPath }}.",
      "errors": {
        "parsing": "Config file could not be parsed"
      }
    },
    "configUtils": {
      "unknownType": "Unknown auth type {{ type }}"
    },
    "state": {
      "ensureCLIDirectory": {
        "errors": {
          "cannotCreateDirectory": "Cannot create CLI state directory: {{ error }}"
        }
      },
      "getCurrentState": {
        "debug": {
          "emptyStateFile": "State file is empty, using default state"
        },
        "errors": {
          "errorReading": "Error reading CLI state, using defaults: {{ error }}"
        }
      },
      "setStateValue": {
        "errors": {
          "failedToWrite": "Failed to write CLI state: {{ error }}"
        }
      }
    },
    "environment": {
      "loadConfig": {
        "missingAccountId": "Unable to load config from environment variables: Missing accountId",
        "missingEnv": "Unable to load config from environment variables: Missing env",
        "unknownAuthType": "Unable to load config from environment variables: Unknown auth type"
      }
    },
    "migrate": {
      "errors": {
        "writeConfig": "Unable to write global configuration file at {{ configPath }}.",
        "noDeprecatedConfig": "No deprecated configuration file found. Skipping migration to global config."
      }
    }
  },
  "models": {
    "OAuth2Manager": {
      "fetchingAccessToken": "Fetching access token for accountId {{ accountId }} for clientId {{ clientId }}",
      "updatingTokenInfo": "Persisting updated tokenInfo for accountId {{ accountId }} for clientId {{ clientId }}",
      "refreshingAccessToken": "Waiting for access token for accountId {{ accountId }}  for clientId {{ clientId }} to be fetched",
      "errors": {
        "missingRefreshToken": "The account {{ accountId }} has not been authenticated with Oauth2",
        "auth": "Error while retrieving new token: {{ token }}"
      }
    },
    "HubSpotConfigError": {
      "baseMessage": "An error occurred while {{ operation }} your HubSpot config {{ configType }}{{ message }}"
    }
  },
  "utils": {
    "notify": {
      "errors": {
        "filePath": "Unable to notify file '{{ filePath }}'"
      }
    },
    "cms": {
      "modules": {
        "throwInvalidPathInput": "Expected Path Input"
      }
    },
    "detectPort": {
      "errors": {
        "invalidPort": "Port must be between {{ minPort }} and {{ maxPort }}"
      }
    },
    "PortManagerServer": {
      "started": "PortManagerServer running on port {{ port }}",
      "setPort": "Server with instanceId {{ instanceId }} assigned to port {{ port }}",
      "deletedPort": "Server with instanceId {{ instanceId }} unassigned from port {{ port }}",
      "close": "PortManagerServer shutting down.",
      "errors": {
        "portInUse": "Failed to start PortManagerServer. Port {{ port }} is already in use.",
        "duplicateInstance": "Failed to start PortManagerServer. An instance of PortManagerServer is already running.",
        "404": "Could not find a server with instanceId {{ instanceId }}",
        "409": "Failed to assign port. Server with instanceId {{ instanceId }} is already running on port {{ port }}",
        "400": "Invalid port requested. Port must be between {{ minPort }} and {{ maxPort }}."
      }
    }
  },
  "http": {
    "index": {
      "createGetRequestStream": {
        "onWrite": "Wrote file {{ filepath }}"
      },
      "errors": {
        "withOauth": "Oauth manager for account {{ accountId }} not found.",
        "withAuth": "Account with id {{ accountId }} not found.",
        "invalidAuthType": "Error authenticating HTTP request: account {{ accountId }} has an invalid auth type {{ authType }}"
      }
    }
  },
  "errors": {
    "fileSystemErrors": {
      "readAction": "reading from",
      "writeAction": "writing to",
      "otherAction": "accessing",
      "unknownFilepath": "a file or folder",
      "baseMessage": "An error occurred while {{ fileAction }} {{ filepath }}."
    },
    "apiErrors": {
      "messageDetail": "{{ requestName }} in account {{ accountId }}",
      "genericMessageDetail": "request",
      "unableToUpload": "Unable to upload \"{{ payload }}.",
      "codes": {
        "400": "The {{ messageDetail }} was bad.",
        "401": "The {{ messageDetail }} was unauthorized.",
        "403": "The {{ messageDetail }} was forbidden.",
        "404": "The {{ messageDetail }} was not found.",
        "429": "The {{ messageDetail }} surpassed the rate limit. Retry in one minute.",
        "503": "The {{ messageDetail }} could not be handled at this time. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists.",
        "500Generic": "The {{ messageDetail }} failed due to a server error. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists.",
        "400Generic": "The {{ messageDetail }} failed due to a client error.",
        "generic": "The {{ messageDetail }} failed."
      }
    }
  }
}