auth0-deploy-cli 7.7.1 → 7.10.0

package/lib/context/yaml/handlers/branding.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,24 +29,30 @@ const tools_1 = require("../../../tools");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the HTML file for each page
-        const { branding } = context.assets;
-        if (!branding || !branding.templates)
+        if (!context.assets.branding)
+            return {
+                branding: {
+                    templates: [],
+                },
+            };
+        const _a = context.assets.branding, { templates } = _a, branding = __rest(_a, ["templates"]);
+        if (!branding && !branding['templates'])
             return { branding };
-        const templates = branding.templates.map((templateDefinition) => {
-            const markupFile = path_1.default.join(templateDefinition.body);
+        const parsedTemplates = templates.map((templateDefinition) => {
+            const markupFile = path_1.default.join(context.basePath, templateDefinition.body);
             return {
                 template: templateDefinition.template,
                 body: (0, tools_1.loadFileAndReplaceKeywords)(markupFile, context.mappings),
             };
         });
         return {
-            branding: Object.assign(Object.assign({}, branding), { templates }),
+            branding: Object.assign(Object.assign({}, branding), { templates: parsedTemplates }),
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { branding } = context.assets || { branding: undefined };
+        const { branding } = context.assets;
         branding.templates = branding.templates || [];
         // create templates folder
         if (branding.templates.length) {

package/lib/context/yaml/handlers/clientGrants.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedClientGrants = {
+    clientGrants: unknown[];
+};
+declare const clientGrantsHandler: YAMLHandler<ParsedClientGrants>;
+export default clientGrantsHandler;

package/lib/context/yaml/handlers/clients.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedClients = {
+    clients: unknown[];
+};
+declare const clientsHandler: YAMLHandler<ParsedClients>;
+export default clientsHandler;

package/lib/context/yaml/handlers/connections.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedConnections = {
+    connections: unknown[];
+};
+declare const connectionsHandler: YAMLHandler<ParsedConnections>;
+export default connectionsHandler;

package/lib/context/yaml/handlers/databases.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedDatabases = {
+    databases: unknown[];
+};
+declare const databasesHandler: YAMLHandler<ParsedDatabases | {}>;
+export default databasesHandler;

package/lib/context/yaml/handlers/emailProvider.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedEmailProvider = {
+    emailProvider: unknown;
+};
+declare const emailProviderHandler: YAMLHandler<ParsedEmailProvider>;
+export default emailProviderHandler;

package/lib/context/yaml/handlers/emailTemplates.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedEmailTemplates = {
+    emailTemplates: unknown[];
+};
+declare const emailTemplatesHandler: YAMLHandler<ParsedEmailTemplates>;
+export default emailTemplatesHandler;

package/lib/context/yaml/handlers/guardianFactorProviders.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianFactorProviders = {
+    guardianFactorProviders: unknown[];
+};
+declare const guardianFactorProvidersHandler: YAMLHandler<ParsedGuardianFactorProviders>;
+export default guardianFactorProvidersHandler;

package/lib/context/yaml/handlers/guardianFactorTemplates.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianFactorTemplates = {
+    guardianFactorTemplates: unknown[];
+};
+declare const guardianFactorTemplatesHandler: YAMLHandler<ParsedGuardianFactorTemplates>;
+export default guardianFactorTemplatesHandler;

package/lib/context/yaml/handlers/guardianFactors.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianFactors = {
+    guardianFactors: unknown[];
+};
+declare const guardianFactorsHandler: YAMLHandler<ParsedGuardianFactors>;
+export default guardianFactorsHandler;

package/lib/context/yaml/handlers/guardianPhoneFactorMessageTypes.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianFactorMessageTypes = {
+    guardianPhoneFactorMessageTypes: unknown;
+};
+declare const guardianPhoneFactorMessageTypesHandler: YAMLHandler<ParsedGuardianFactorMessageTypes>;
+export default guardianPhoneFactorMessageTypesHandler;

package/lib/context/yaml/handlers/guardianPhoneFactorSelectedProvider.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianPhoneFactorSelectedProvider = {
+    guardianPhoneFactorSelectedProvider: unknown;
+};
+declare const guardianPhoneFactorSelectedProviderHandler: YAMLHandler<ParsedGuardianPhoneFactorSelectedProvider>;
+export default guardianPhoneFactorSelectedProviderHandler;

package/lib/context/yaml/handlers/guardianPolicies.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedGuardianPolicies = {
+    guardianPolicies: unknown;
+};
+declare const guardianPoliciesHandler: YAMLHandler<ParsedGuardianPolicies>;
+export default guardianPoliciesHandler;

package/lib/context/yaml/handlers/hooks.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedHooks = {
+    hooks: unknown[];
+} | {};
+declare const hooksHandler: YAMLHandler<ParsedHooks>;
+export default hooksHandler;

package/lib/context/yaml/handlers/index.d.ts

@@ -0,0 +1,12 @@
+import YAMLContext from '..';
+import { AssetTypes } from '../../../types';
+export declare type YAMLHandler<T> = {
+    dump: (context: YAMLContext) => Promise<T | {}>;
+    parse: (context: YAMLContext) => Promise<T>;
+};
+declare const yamlHandlers: {
+    [key in AssetTypes]: YAMLHandler<{
+        [key: string]: unknown;
+    }>;
+};
+export default yamlHandlers;

package/lib/context/yaml/handlers/index.js

@@ -28,6 +28,7 @@ const actions_1 = __importDefault(require("./actions"));
 const triggers_1 = __importDefault(require("./triggers"));
 const attackProtection_1 = __importDefault(require("./attackProtection"));
 const branding_1 = __importDefault(require("./branding"));
+const logStreams_1 = __importDefault(require("./logStreams"));
 const yamlHandlers = {
     rules: rules_1.default,
     hooks: hooks_1.default,
@@ -54,5 +55,6 @@ const yamlHandlers = {
     triggers: triggers_1.default,
     attackProtection: attackProtection_1.default,
     branding: branding_1.default,
+    logStreams: logStreams_1.default,
 };
 exports.default = yamlHandlers;

package/lib/context/yaml/handlers/logStreams.d.ts

@@ -0,0 +1,7 @@
+import { YAMLHandler } from '.';
+import { Asset } from '../../../types';
+declare type ParsedLogStreams = {
+    logStreams: Asset[] | null;
+};
+declare const logStreamsHandler: YAMLHandler<ParsedLogStreams>;
+export default logStreamsHandler;

package/lib/context/yaml/handlers/logStreams.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseAndDump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return {
+            logStreams: context.assets.logStreams || [],
+        };
+    });
+}
+const logStreamsHandler = {
+    parse: parseAndDump,
+    dump: parseAndDump,
+};
+exports.default = logStreamsHandler;

package/lib/context/yaml/handlers/migrations.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedMigrations = {
+    migrations: unknown[];
+};
+declare const migrationsHandler: YAMLHandler<ParsedMigrations>;
+export default migrationsHandler;

package/lib/context/yaml/handlers/organizations.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedOrganizations = {
+    organizations: unknown[];
+};
+declare const organizationsHandler: YAMLHandler<ParsedOrganizations>;
+export default organizationsHandler;

package/lib/context/yaml/handlers/pages.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedPages = {
+    pages: unknown[];
+} | {};
+declare const pagesHandler: YAMLHandler<ParsedPages>;
+export default pagesHandler;

package/lib/context/yaml/handlers/resourceServers.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedResourceServers = {
+    resourceServers: unknown[];
+};
+declare const resourceServersHandler: YAMLHandler<ParsedResourceServers>;
+export default resourceServersHandler;

package/lib/context/yaml/handlers/roles.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedRoles = {
+    roles: unknown[];
+};
+declare const rolesHandler: YAMLHandler<ParsedRoles>;
+export default rolesHandler;

package/lib/context/yaml/handlers/rules.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedRules = {
+    rules: unknown[];
+} | {};
+declare const rulesHandler: YAMLHandler<ParsedRules>;
+export default rulesHandler;

package/lib/context/yaml/handlers/rulesConfigs.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedRulesConfigs = {
+    rulesConfigs: unknown[];
+} | {};
+declare const rulesConfigsHandler: YAMLHandler<ParsedRulesConfigs>;
+export default rulesConfigsHandler;

package/lib/context/yaml/handlers/tenant.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedTenant = {
+    tenant: unknown[];
+} | {};
+declare const tenantHandler: YAMLHandler<ParsedTenant>;
+export default tenantHandler;

package/lib/context/yaml/handlers/triggers.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+declare type ParsedTriggers = {
+    triggers: unknown[];
+} | {};
+declare const triggersHandler: YAMLHandler<ParsedTriggers>;
+export default triggersHandler;

package/lib/context/yaml/index.d.ts

@@ -0,0 +1,13 @@
+import { Assets, Config, Auth0APIClient, KeywordMappings } from '../../types';
+export default class YAMLContext {
+    basePath: string;
+    configFile: string;
+    config: Config;
+    mappings: KeywordMappings;
+    mgmtClient: Auth0APIClient;
+    assets: Assets;
+    constructor(config: Config, mgmtClient: any);
+    loadFile(f: any): string;
+    load(): Promise<void>;
+    dump(): Promise<void>;
+}

package/lib/index.d.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import importCMD from './commands/import';
+import exportCMD from './commands/export';
+declare const _default: {
+    deploy: typeof importCMD;
+    dump: typeof exportCMD;
+    import: typeof importCMD;
+    export: typeof exportCMD;
+    tools: {
+        constants: {
+            CONCURRENT_CALLS: number;
+            RULES_DIRECTORY: string;
+            RULES_STAGES: string[];
+            DEFAULT_RULE_STAGE: string;
+            HOOKS_HIDDEN_SECRET_VALUE: string;
+            OBFUSCATED_SECRET_VALUE: string;
+            HOOKS_DIRECTORY: string;
+            ACTIONS_DIRECTORY: string;
+            TRIGGERS_DIRECTORY: string;
+            RULES_CONFIGS_DIRECTORY: string;
+            PAGES_DIRECTORY: string;
+            PAGE_LOGIN: string;
+            PAGE_GUARDIAN_MULTIFACTOR: string;
+            PAGE_PASSWORD_RESET: string;
+            PAGE_ERROR: string;
+            DATABASE_CONNECTIONS_DIRECTORY: string;
+            DATABASE_SCRIPTS_CHANGE_EMAIL: string;
+            DATABASE_SCRIPTS_GET_USER: string;
+            EMAIL_TEMPLATES_TYPES: string[];
+            ACTIONS_TRIGGERS: string[];
+            EMAIL_TEMPLATES_DIRECTORY: string;
+            EMAIL_VERIFY: string;
+            EMAIL_VERIFY_BY_CODE: string;
+            EMAIL_RESET: string;
+            EMAIL_WELCOME: string;
+            EMAIL_BLOCKED: string;
+            EMAIL_STOLEN_CREDENTIALS: string;
+            EMAIL_ENROLLMENT: string;
+            EMAIL_CHANGE_PASSWORD: string;
+            EMAIL_PASSWORD_RESET: string;
+            EMAIL_MFA_OOB_CODE: string;
+            EMAIL_USER_INVITATION: string;
+            GUARDIAN_DIRECTORY: string;
+            GUARDIAN_FACTORS_DIRECTORY: string;
+            GUARDIAN_PROVIDERS_DIRECTORY: string;
+            GUARDIAN_TEMPLATES_DIRECTORY: string;
+            UNIVERSAL_LOGIN_TEMPLATE: string;
+            RESOURCE_SERVERS_DIRECTORY: string;
+            RESOURCE_SERVERS_CLIENT_NAME: string;
+            RESOURCE_SERVERS_MANAGEMENT_API_NAME: string;
+            RESOURCE_SERVERS_ID_NAME: string;
+            CLIENTS_DIRECTORY: string;
+            CLIENTS_GRANTS_DIRECTORY: string;
+            BRANDING_DIRECTORY: string;
+            BRANDING_TEMPLATES_DIRECTORY: string;
+            BRANDING_TEMPLATES_YAML_DIRECTORY: string;
+            CLIENTS_CLIENT_NAME: string;
+            CLIENTS_CLIENT_ID_NAME: string;
+            CONNECTIONS_DIRECTORY: string;
+            CONNECTIONS_CLIENT_NAME: string;
+            CONNECTIONS_ID_NAME: string;
+            ROLES_DIRECTORY: string;
+            ATTACK_PROTECTION_DIRECTORY: string;
+            GUARDIAN_FACTORS: string[];
+            GUARDIAN_POLICIES: string[];
+            GUARDIAN_PHONE_PROVIDERS: string[];
+            GUARDIAN_PHONE_MESSAGE_TYPES: string[];
+            GUARDIAN_FACTOR_TEMPLATES: string[];
+            GUARDIAN_FACTOR_PROVIDERS: {
+                sms: string[];
+                'push-notification': string[];
+            };
+            PAGE_NAMES: string[];
+            DATABASE_SCRIPTS: string[];
+            DATABASE_SCRIPTS_NO_IMPORT: string[];
+            DATABASE_SCRIPTS_IMPORT: string[];
+            EMAIL_TEMPLATES_NAMES: string[];
+            SUPPORTED_BRANDING_TEMPLATES: string[];
+            LOG_STREAMS_DIRECTORY: string;
+        };
+        deploy: typeof import("./tools").deploy;
+        keywordReplace: typeof import("./tools").keywordReplace;
+        loadFileAndReplaceKeywords: typeof import("./tools").loadFileAndReplaceKeywords;
+        Auth0: typeof import("./tools").Auth0;
+    };
+};
+export default _default;
+export declare const dump: typeof exportCMD;
+export declare const deploy: typeof importCMD;

package/lib/index.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = exports.dump = void 0;
 const global_agent_1 = require("global-agent");
 const args_1 = require("./args");
 const logger_1 = __importDefault(require("./logger"));
@@ -49,7 +50,7 @@ if (require.main === module) {
     const params = (0, args_1.getParams)();
     logger_1.default.debug('Starting Auth0 Deploy CLI Tool');
     if (params.debug) {
-        logger_1.default.transports.console.level = 'debug';
+        logger_1.default.level = 'debug';
         // Set for tools
         process.env.AUTH0_DEBUG = 'true';
         process.env.AUTH0_LOG = 'debug';
@@ -76,10 +77,12 @@ if (require.main === module) {
     });
 }
 // Export commands to be used programmatically
-module.exports = {
+exports.default = {
     deploy: import_1.default,
     dump: export_1.default,
     import: import_1.default,
     export: export_1.default,
     tools: tools_1.default,
 };
+exports.dump = export_1.default;
+exports.deploy = import_1.default;

package/lib/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("winston").Logger;
+export default logger;

package/lib/logger.js

@@ -1,21 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const winston_1 = __importDefault(require("winston"));
-//@ts-ignore because used version of Winston still supports emitErrs property
-winston_1.default.emitErrs = true;
-const log = new winston_1.default.Logger({
-    transports: [
-        new winston_1.default.transports.Console({
-            timestamp: true,
-            level: process.env.AUTH0_LOG || 'info',
-            handleExceptions: true,
-            json: false,
-            colorize: true,
-        }),
-    ],
+const winston_1 = require("winston");
+const { combine, timestamp, colorize } = winston_1.format;
+const logger = (0, winston_1.createLogger)({
+    level: process.env.AUTH0_LOG || 'info',
+    format: combine(colorize(), timestamp(), winston_1.format.printf((info) => `${info.timestamp} - ${info.level}: ${info.message}`)),
+    transports: [new winston_1.transports.Console()],
     exitOnError: false,
 });
-exports.default = log;
+exports.default = logger;

package/lib/readonly.d.ts

@@ -0,0 +1,2 @@
+import { Assets, Config } from './types';
+export default function cleanAssets(assets: Assets, config: Config): Assets;

package/lib/sessionDurationsToMinutes.d.ts

@@ -0,0 +1,7 @@
+export declare const sessionDurationsToMinutes: ({ session_lifetime, idle_session_lifetime, }: {
+    session_lifetime?: number | undefined;
+    idle_session_lifetime?: number | undefined;
+}) => {
+    session_lifetime_in_minutes?: number;
+    idle_session_lifetime_in_minutes?: number;
+};

package/lib/tools/auth0/client.d.ts

@@ -0,0 +1,2 @@
+import { Auth0APIClient, BaseAuth0APIClient } from '../../types';
+export default function pagedClient(client: BaseAuth0APIClient): Auth0APIClient;

package/lib/tools/auth0/handlers/actions.d.ts

@@ -0,0 +1,95 @@
+import DefaultAPIHandler from './default';
+import { Asset } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            code: {
+                type: string;
+                default: string;
+            };
+            runtime: {
+                type: string;
+            };
+            dependencies: {
+                type: string;
+                items: {
+                    type: string;
+                    additionalProperties: boolean;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        version: {
+                            type: string;
+                        };
+                        registry_url: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            secrets: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        updated_at: {
+                            type: string;
+                            format: string;
+                        };
+                    };
+                };
+            };
+            name: {
+                type: string;
+                default: string;
+            };
+            supported_triggers: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                            default: string;
+                        };
+                        version: {
+                            type: string;
+                        };
+                        url: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            deployed: {
+                type: string;
+            };
+            status: {
+                type: string;
+            };
+        };
+    };
+};
+export default class ActionHandler extends DefaultAPIHandler {
+    existing: Asset[] | null;
+    constructor(options: any);
+    createAction(action: any): Promise<Asset>;
+    deleteAction(action: any): Promise<void | never[]>;
+    objString(action: any): string;
+    deployActions(actions: any): Promise<void>;
+    deployAction(action: any): Promise<void>;
+    actionChanges(action: any, found: any): Promise<Asset>;
+    getType(): Promise<Asset[] | null>;
+    processChanges(assets: any): Promise<void>;
+}

package/lib/tools/auth0/handlers/actions.js

@@ -44,7 +44,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 const utils_1 = require("../../utils");
 const MAX_ACTION_DEPLOY_RETRY = 60;
 // With this schema, we can only validate property types but not valid properties on per type basis

package/lib/tools/auth0/handlers/attackProtection.d.ts

@@ -0,0 +1,28 @@
+import DefaultAPIHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        breachedPasswordDetection: {
+            type: string;
+        };
+        bruteForceProtection: {
+            type: string;
+        };
+        suspiciousIpThrottling: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export default class AttackProtectionHandler extends DefaultAPIHandler {
+    existing: {
+        breachedPasswordDetection: any;
+        bruteForceProtection: any;
+        suspiciousIpThrottling: any;
+    } | null;
+    constructor(config: DefaultAPIHandler);
+    objString(item: Asset): string;
+    getType(): Promise<Asset>;
+    processChanges(assets: Assets): Promise<void>;
+}

package/lib/tools/auth0/handlers/branding.d.ts

@@ -0,0 +1,27 @@
+import DefaultHandler from './default';
+import { Asset } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        templates: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    template: {
+                        type: string;
+                    };
+                    body: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default class BrandingHandler extends DefaultHandler {
+    existing: Asset;
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset>;
+    processChanges(assets: any): Promise<void>;
+}