auth0-deploy-cli 7.7.1 → 7.8.0

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

@@ -0,0 +1,25 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                enum: string[];
+            };
+            provider: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class GuardianFactorProvidersHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import DefaultHandler from './default';
+import { Assets, Asset } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class GuardianFactorTemplatesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: any);
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class GuardianFactorsHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        message_types: {
+            type: string;
+            items: {
+                type: string;
+                enum: string[];
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export default class GuardianPhoneMessageTypesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[] | {}>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        provider: {
+            type: string;
+            enum: string[];
+        };
+    };
+    additionalProperties: boolean;
+};
+export default class GuardianPhoneSelectedProviderHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: any);
+    getType(): Promise<{}>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        policies: {
+            type: string;
+            items: {
+                type: string;
+                enum: string[];
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export default class GuardianPoliciesHandler extends DefaultHandler {
+    existing: {
+        policies: Asset[];
+    };
+    constructor(options: any);
+    getType(): Promise<GuardianPoliciesHandler['existing'] | {}>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,58 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        default: never[];
+        properties: {
+            script: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            name: {
+                type: string;
+                description: string;
+                pattern: string;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            triggerId: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            secrets: {
+                type: string;
+                description: string;
+                default: {};
+            };
+            dependencies: {
+                type: string;
+                default: {};
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class HooksHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    objString(hook: any): string;
+    processSecrets(hooks: any): Promise<void>;
+    getType(reload: boolean): Promise<Asset[]>;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+    validate(assets: any): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,129 @@
+import APIHandler from './default';
+declare const _default: {
+    rules: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    rulesConfigs: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    hooks: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    pages: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    databases: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    clientGrants: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    resourceServers: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    clients: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    connections: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    tenant: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    emailProvider: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    emailTemplates: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactors: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactorProviders: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactorTemplates: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    migrations: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPhoneFactorMessageTypes: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPhoneFactorSelectedProvider: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPolicies: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    roles: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    actions: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    organizations: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    triggers: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    attackProtection: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    branding: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    additionalProperties: {
+        type: string;
+    };
+};
+export default class MigrationsHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[] | {}>;
+    processChanges(assets: Assets): Promise<void>;
+    logUnavailableMigrations(ignoreUnavailableMigrations: boolean, ignoredMigrations: string[]): void;
+    removeUnavailableMigrations(migrations: Asset[]): Promise<Asset[]>;
+}

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

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'object',
     additionalProperties: { type: 'boolean' },

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

@@ -0,0 +1,51 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            display_name: {
+                type: string;
+            };
+            branding: {
+                type: string;
+            };
+            metadata: {
+                type: string;
+            };
+            connections: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        connection_id: {
+                            type: string;
+                        };
+                        assign_membership_on_login: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export default class OrganizationsHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(config: DefaultHandler);
+    deleteOrganization(org: any): Promise<void>;
+    deleteOrganizations(data: any): Promise<void>;
+    createOrganization(org: any): Promise<Asset>;
+    createOrganizations(creates: CalculatedChanges['create']): Promise<void>;
+    updateOrganization(org: any, organizations: any): Promise<{
+        id: any;
+    }>;
+    updateOrganizations(updates: CalculatedChanges['update'], orgs: Asset[]): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -45,7 +45,7 @@ exports.schema = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'array',
     items: {

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

@@ -0,0 +1,42 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const supportedPages: string[];
+export declare const pageNameMap: {
+    guardian_multifactor: string;
+    password_reset: string;
+    error_page: string;
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                enum: string[];
+            };
+            html: {
+                type: string;
+                default: string;
+            };
+            url: {
+                type: string;
+            };
+            show_log_link: {
+                type: string;
+            };
+            enabled: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class PagesHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    objString(page: any): string;
+    updateLoginPage(page: any): Promise<void>;
+    updatePages(pages: Asset[]): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+};
+export default class PromptsHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,51 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            identifier: {
+                type: string;
+            };
+            scopes: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            enforce_policies: {
+                type: string;
+            };
+            token_dialect: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class ResourceServersHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    objString(resourceServer: any): string;
+    getType(): Promise<Asset[]>;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+    validate(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            id: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            permissions: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        permission_name: {
+                            type: string;
+                        };
+                        resource_server_identifier: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export default class RolesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(config: DefaultHandler);
+    createRole(data: any): Promise<Asset>;
+    createRoles(creates: CalculatedChanges['create']): Promise<void>;
+    deleteRole(data: any): Promise<void>;
+    deleteRoles(dels: CalculatedChanges['del']): Promise<void>;
+    updateRole(data: any, roles: any): Promise<{
+        id: any;
+    }>;
+    updateRoles(updates: CalculatedChanges['update'], roles: any): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -44,7 +44,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'array',
     items: {

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

@@ -0,0 +1,55 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        default: never[];
+        properties: {
+            script: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            name: {
+                type: string;
+                description: string;
+                pattern: string;
+            };
+            order: {
+                type: string[];
+                description: string;
+                default: null;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            stage: {
+                type: string;
+                description: string;
+                default: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class RulesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(rule: any): string;
+    calcChanges(assets: any, includeExcluded?: boolean): Promise<CalculatedChanges & {
+        reOrder: Asset[];
+    }>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -16,7 +16,7 @@ exports.schema = exports.excludeSchema = void 0;
 const validationError_1 = __importDefault(require("../../validationError"));
 const utils_1 = require("../../utils");
 const default_1 = __importDefault(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 const calculateChanges_1 = require("../../calculateChanges");
 exports.excludeSchema = {
     type: 'array',

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

@@ -0,0 +1,25 @@
+import { Assets, Asset, CalculatedChanges } from '../../../types';
+import DefaultHandler from './default';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            key: {
+                type: string;
+                pattern: string;
+            };
+            value: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+    additionalProperties: boolean;
+};
+export default class RulesConfigsHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(item: any): string;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+}

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

@@ -0,0 +1,11 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+};
+export default class TenantHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}