sb-mig 3.1.3 → 3.1.7

package/dist/api/componentPresets.d.ts

@@ -0,0 +1 @@
+export declare const getComponentPresets: (componentName: string | undefined) => Promise<false | any[]>;

package/dist/api/componentPresets.js

@@ -0,0 +1,18 @@
+import Logger from "../utils/logger.js";
+import { getAllComponents } from "./components.js";
+import { getPreset } from "./presets.js";
+export const getComponentPresets = (componentName) => {
+    Logger.log(`Trying to get all '${componentName}' presets.`);
+    return getAllComponents().then(async (res) => {
+        const componentPresets = res.components.filter((component) => component.name === componentName);
+        if (componentPresets.length > 0) {
+            if (componentPresets[0].all_presets.length === 0) {
+                Logger.warning(`There is no presets for: '${componentName}' component`);
+                return false;
+            }
+            return Promise.all(componentPresets[0].all_presets.map((preset) => getPreset(preset.id).catch((err) => Logger.error(err))));
+        }
+        Logger.warning(`There is no '${componentName}' component`);
+        return false;
+    });
+};

package/dist/api/components.d.ts

@@ -0,0 +1,5 @@
+export declare const getAllComponents: () => Promise<any>;
+export declare const getComponent: (componentName: string | undefined) => Promise<any>;
+export declare const getComponentsGroup: (groupName: string | undefined) => Promise<any>;
+export declare const getAllComponentsGroups: () => Promise<any>;
+export declare const createComponentsGroup: (groupName: string) => Promise<any>;

package/dist/api/components.js

@@ -0,0 +1,63 @@
+import storyblokConfig from "../config/config.js";
+import { sbApi } from "./config.js";
+const { spaceId } = storyblokConfig;
+// GET
+export const getAllComponents = () => {
+    console.log("Trying to get all components.");
+    return sbApi
+        .get(`spaces/${spaceId}/components/`)
+        .then((res) => res.data)
+        .catch((err) => console.error(err));
+};
+export const getComponent = (componentName) => {
+    console.log(`Trying to get '${componentName}' component.`);
+    return getAllComponents()
+        .then((res) => res.components.filter((component) => component.name === componentName))
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            console.info(`There is no component named '${componentName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => console.error(err));
+};
+export const getComponentsGroup = (groupName) => {
+    console.log(`Trying to get '${groupName}' group.`);
+    return getAllComponentsGroups()
+        .then((res) => {
+        return res.component_groups.filter((group) => group.name === groupName);
+    })
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            console.info(`There is no group named '${groupName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => console.error(err));
+};
+export const getAllComponentsGroups = async () => {
+    console.log("Trying to get all groups.");
+    return sbApi
+        .get(`spaces/${spaceId}/component_groups/`)
+        .then((response) => response.data)
+        .catch((err) => console.error(err));
+};
+export const createComponentsGroup = (groupName) => {
+    console.log(`Trying to create '${groupName}' group`);
+    return sbApi
+        .post(`spaces/${spaceId}/component_groups/`, {
+        component_group: {
+            name: groupName,
+        },
+    })
+        .then((res) => {
+        console.info(`'${groupName}' created with uuid: ${res.data.component_group.uuid}`);
+        return res.data;
+    })
+        .catch((err) => {
+        console.log(err.message);
+        console.error("Error happened :()");
+    });
+};

package/dist/api/config.d.ts

@@ -0,0 +1,2 @@
+import StoryblokClient from "storyblok-js-client";
+export declare const sbApi: StoryblokClient;

package/dist/api/config.js

@@ -0,0 +1,4 @@
+import StoryblokClient from "storyblok-js-client";
+import storyblokConfig from "../config/config.js";
+const { accessToken, oauthToken, storyblokApiUrl } = storyblokConfig;
+export const sbApi = new StoryblokClient({ accessToken, oauthToken }, storyblokApiUrl);

package/dist/api/datasources.d.ts

@@ -0,0 +1,24 @@
+export declare const getAllDatasources: () => Promise<any>;
+export declare const getDatasource: (datasourceName: string | undefined) => Promise<any>;
+export declare const getDatasourceEntries: (datasourceName: string) => Promise<any>;
+export declare const createDatasource: (datasource: any) => Promise<void | {
+    data: any;
+    datasource_entries: any;
+}>;
+export declare const createDatasourceEntry: (datasourceEntry: any, datasourceId: string) => Promise<any>;
+export declare const updateDatasourceEntry: (datasourceEntry: any, datasourceId: string, datasourceToBeUpdated: any) => Promise<any>;
+export declare const updateDatasource: (datasource: any, temp: any) => Promise<void | {
+    data: any;
+    datasource_entries: any;
+}>;
+export declare const createDatasourceEntries: (datasourceId: string, datasource_entries: any, remoteDatasourceEntries: any) => void;
+interface SyncDatasources {
+    providedDatasources: string[];
+}
+export declare const syncDatasources: ({ providedDatasources, }: SyncDatasources) => Promise<void>;
+interface SyncProvidedDatasources {
+    datasources: string[];
+}
+export declare const syncProvidedDatasources: ({ datasources, }: SyncProvidedDatasources) => void;
+export declare const syncAllDatasources: () => void;
+export {};

package/dist/api/datasources.js

@@ -0,0 +1,181 @@
+import Logger from "../utils/logger.js";
+import storyblokConfig from "../config/config.js";
+import { sbApi } from "./config.js";
+import { LOOKUP_TYPE, SCOPE, discoverManyDatasources, discoverDatasources, } from "../utils/discover.js";
+import { getFilesContentWithRequire } from "../utils/main.js";
+const { spaceId } = storyblokConfig;
+// GET
+export const getAllDatasources = () => {
+    Logger.log("Trying to get all Datasources.");
+    return sbApi
+        .get(`spaces/${spaceId}/datasources/`)
+        .then(({ data }) => data)
+        .catch((err) => {
+        if (err.response.status === 404) {
+            Logger.error(`There is no datasources in your Storyblok ${spaceId} space.`);
+            return true;
+        }
+        else {
+            Logger.error(err);
+            return false;
+        }
+    });
+};
+export const getDatasource = (datasourceName) => {
+    Logger.log(`Trying to get '${datasourceName}' datasource.`);
+    return getAllDatasources()
+        .then((res) => {
+        if (res) {
+            return res.datasources.filter((datasource) => datasource.name === datasourceName);
+        }
+    })
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            Logger.warning(`There is no datasource named '${datasourceName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => Logger.error(err));
+};
+export const getDatasourceEntries = async (datasourceName) => {
+    Logger.log(`Trying to get '${datasourceName}' datasource entries.`);
+    const data = await getDatasource(datasourceName);
+    if (data) {
+        return sbApi
+            .get(`spaces/${spaceId}/datasource_entries/?datasource_id=${data[0].id}`)
+            .then(async ({ data }) => data)
+            .catch((err) => Logger.error(err));
+    }
+};
+export const createDatasource = (datasource) => sbApi
+    .post(`spaces/${spaceId}/datasources/`, {
+    datasource: {
+        name: datasource.name,
+        slug: datasource.slug,
+    },
+})
+    .then(({ data }) => ({
+    data,
+    datasource_entries: datasource.datasource_entries,
+}))
+    .catch((err) => Logger.error(err));
+export const createDatasourceEntry = (datasourceEntry, datasourceId) => {
+    return sbApi
+        .post(`spaces/${spaceId}/datasource_entries/`, {
+        datasource_entry: {
+            name: Object.values(datasourceEntry)[0],
+            value: Object.values(datasourceEntry)[1],
+            datasource_id: datasourceId,
+        },
+    })
+        .then(({ data }) => {
+        return data;
+    })
+        .catch((err) => Logger.error(err));
+};
+export const updateDatasourceEntry = (datasourceEntry, datasourceId, datasourceToBeUpdated) => {
+    return sbApi
+        .put(`spaces/${spaceId}/datasource_entries/${datasourceToBeUpdated.id}`, {
+        datasource_entry: {
+            name: Object.values(datasourceEntry)[0],
+            value: Object.values(datasourceEntry)[1],
+            datasource_id: datasourceId,
+            id: datasourceToBeUpdated.id,
+        },
+    })
+        .then(({ data }) => {
+        return data;
+    })
+        .catch((err) => Logger.error(err));
+};
+export const updateDatasource = (datasource, temp) => sbApi
+    .put(`spaces/${spaceId}/datasources/${temp.id}`, {
+    datasource: {
+        id: temp.id,
+        name: datasource.name,
+        slug: datasource.slug,
+    },
+})
+    .then(({ data }) => {
+    return {
+        data,
+        datasource_entries: datasource.datasource_entries,
+    };
+})
+    .catch((err) => Logger.error(err));
+export const createDatasourceEntries = (datasourceId, datasource_entries, remoteDatasourceEntries) => {
+    Promise.all(datasource_entries.map((datasourceEntry) => {
+        const datasourceEntriesToBeUpdated = remoteDatasourceEntries.datasource_entries.find((remoteDatasourceEntry) => remoteDatasourceEntry.name ===
+            Object.values(datasourceEntry)[0]);
+        if (datasourceEntriesToBeUpdated) {
+            return updateDatasourceEntry(datasourceEntry, datasourceId, datasourceEntriesToBeUpdated);
+        }
+        return createDatasourceEntry(datasourceEntry, datasourceId);
+    }))
+        .then(({ data }) => {
+        Logger.success(`Datasource entries for ${datasourceId} datasource id has been successfully synced.`);
+        return data;
+    })
+        .catch((err) => Logger.error(err));
+};
+export const syncDatasources = async ({ providedDatasources, }) => {
+    Logger.log(`Trying to sync provided datasources: ${providedDatasources}`);
+    const providedDatasourcesContent = getFilesContentWithRequire({
+        files: providedDatasources,
+    });
+    const remoteDatasources = await getAllDatasources();
+    Promise.all(providedDatasourcesContent.map((datasource) => {
+        const datasourceToBeUpdated = remoteDatasources.datasources.find((remoteDatasource) => datasource.name === remoteDatasource.name);
+        if (datasourceToBeUpdated) {
+            return updateDatasource(datasource, datasourceToBeUpdated);
+        }
+        return createDatasource(datasource);
+    }))
+        .then((res) => {
+        res.map(async ({ data, datasource_entries }) => {
+            const remoteDatasourceEntries = await getDatasourceEntries(data.datasource.name);
+            createDatasourceEntries(data.datasource.id, datasource_entries, remoteDatasourceEntries);
+        });
+        return res;
+    })
+        .catch((err) => {
+        console.log(err);
+        Logger.warning("There is error inside promise.all from datasource");
+        return false;
+    });
+};
+export const syncProvidedDatasources = ({ datasources, }) => {
+    const allLocalDatasources = discoverManyDatasources({
+        scope: SCOPE.local,
+        type: LOOKUP_TYPE.fileName,
+        fileNames: datasources,
+    });
+    const allExternalDatasources = discoverManyDatasources({
+        scope: SCOPE.external,
+        type: LOOKUP_TYPE.fileName,
+        fileNames: datasources,
+    });
+    syncDatasources({
+        providedDatasources: [
+            ...allLocalDatasources,
+            ...allExternalDatasources,
+        ],
+    });
+};
+export const syncAllDatasources = () => {
+    const allLocalDatasources = discoverDatasources({
+        scope: SCOPE.local,
+        type: LOOKUP_TYPE.fileName,
+    });
+    const allExternalDatasources = discoverDatasources({
+        scope: SCOPE.external,
+        type: LOOKUP_TYPE.fileName,
+    });
+    syncDatasources({
+        providedDatasources: [
+            ...allLocalDatasources,
+            ...allExternalDatasources,
+        ],
+    });
+};

package/dist/api/migrate.d.ts

@@ -0,0 +1,17 @@
+import { OneComponent } from "../utils/discover.js";
+interface SyncComponents {
+    specifiedComponents: OneComponent[];
+    presets: boolean;
+}
+export declare const syncComponents: ({ specifiedComponents, presets, }: SyncComponents) => Promise<void>;
+interface SyncAllComponents {
+    presets: boolean;
+}
+interface SyncProvidedComponents {
+    presets: boolean;
+    components: string[];
+    packageName: boolean;
+}
+export declare const syncProvidedComponents: ({ components, presets, packageName, }: SyncProvidedComponents) => void;
+export declare const syncAllComponents: ({ presets }: SyncAllComponents) => void;
+export {};

package/dist/api/migrate.js

@@ -0,0 +1,139 @@
+import Logger from "../utils/logger.js";
+import { getAllComponentsGroups, createComponentsGroup, getAllComponents, } from "./components.js";
+import { updateComponent, createComponent } from "./mutateComponents.js";
+import { discoverManyByPackageName, LOOKUP_TYPE, SCOPE, compare, discover, discoverMany, } from "../utils/discover.js";
+import { getFileContent } from "../utils/main.js";
+const _uniqueValuesFrom = (array) => [...new Set(array)];
+const _checkAndPrepareGroups = async (groupsToCheck) => {
+    const componentsGroups = await getAllComponentsGroups();
+    const groupExist = (groupName) => componentsGroups.component_groups.find((group) => group.name === groupName);
+    groupsToCheck.forEach(async (groupName) => {
+        if (!groupExist(groupName)) {
+            await createComponentsGroup(groupName);
+        }
+    });
+};
+const _resolveGroups = async (component, existedGroups, remoteComponentsGroups) => {
+    if (!component.component_group_name) {
+        return { ...component, component_group_uuid: null };
+    }
+    const componentsGroup = existedGroups.find((group) => component.component_group_name === group);
+    if (componentsGroup) {
+        const component_group_uuid = remoteComponentsGroups.component_groups.find((remoteComponentsGroup) => remoteComponentsGroup.name === componentsGroup).uuid;
+        return { ...component, component_group_uuid };
+    }
+};
+export const syncComponents = async ({ specifiedComponents, presets, }) => {
+    Logger.log("sync2Components: ");
+    const specifiedComponentsContent = await Promise.all(specifiedComponents.map((component) => getFileContent({ file: component.path })));
+    const groupsToCheck = _uniqueValuesFrom(specifiedComponentsContent
+        .filter((component) => component.component_group_name)
+        .map((component) => component.component_group_name));
+    console.log(groupsToCheck);
+    await _checkAndPrepareGroups(groupsToCheck);
+    // after checkAndPrepareGroups remoteComponents will have synced groups with local groups
+    // updates of the groups had to happen before creation of them, cause creation/updates of components
+    // happens async, so if one component will have the same group, as other one
+    // it will be race of condition kinda issue - we will never now, if the group for current processed component
+    // already exist or is being created by other request
+    const remoteComponents = await getAllComponents();
+    const componentsToUpdate = [];
+    const componentsToCreate = [];
+    for (const component of specifiedComponentsContent) {
+        const shouldBeUpdated = remoteComponents.components.find((remoteComponent) => component.name === remoteComponent.name);
+        if (shouldBeUpdated) {
+            componentsToUpdate.push({ id: shouldBeUpdated.id, ...component });
+        }
+        else {
+            componentsToCreate.push(component);
+        }
+    }
+    const componentsGroups = await getAllComponentsGroups();
+    componentsToUpdate.length > 0 &&
+        Promise.all(componentsToUpdate.map((component) => _resolveGroups(component, groupsToCheck, componentsGroups))).then((res) => {
+            Logger.log("Components to update after check: ");
+            res.map((component) => {
+                Logger.warning(`   ${component.name}`);
+                updateComponent(component, presets);
+            });
+        });
+    componentsToCreate.length > 0 &&
+        Promise.all(componentsToCreate.map((component) => _resolveGroups(component, groupsToCheck, componentsGroups))).then((res) => {
+            Logger.log("Components to create after check: ");
+            res.map((component) => {
+                Logger.warning(`   ${component.name}`);
+                createComponent(component, presets);
+            });
+        });
+};
+export const syncProvidedComponents = ({ components, presets, packageName, }) => {
+    if (!packageName) {
+        // #1: discover all external .sb.js files
+        const allLocalSbComponentsSchemaFiles = discoverMany({
+            scope: SCOPE.local,
+            type: LOOKUP_TYPE.fileName,
+            fileNames: components,
+        });
+        // #2: discover all local .sb.js files
+        const allExternalSbComponentsSchemaFiles = discoverMany({
+            scope: SCOPE.external,
+            type: LOOKUP_TYPE.fileName,
+            fileNames: components,
+        });
+        // #3: compare results, prefer local ones (so we have to create final external paths array and local array of things to sync from where)
+        const { local, external } = compare({
+            local: allLocalSbComponentsSchemaFiles,
+            external: allExternalSbComponentsSchemaFiles,
+        });
+        // #4: sync - do all stuff already done (groups resolving, and so on)
+        syncComponents({
+            presets,
+            specifiedComponents: [...local, ...external],
+        });
+    }
+    else {
+        // implement discovering and syncrhonizing with packageName
+        // #1: discover all external .sb.js files
+        const allLocalSbComponentsSchemaFiles = discoverManyByPackageName({
+            scope: SCOPE.local,
+            packageNames: components,
+        });
+        // #2: discover all local .sb.js files
+        const allExternalSbComponentsSchemaFiles = discoverManyByPackageName({
+            scope: SCOPE.external,
+            packageNames: components,
+        });
+        // #3: compare results, prefer local ones (so we have to create final external paths array and local array of things to sync from where)
+        const { local, external } = compare({
+            local: allLocalSbComponentsSchemaFiles,
+            external: allExternalSbComponentsSchemaFiles,
+        });
+        // #4: sync - do all stuff already done (groups resolving, and so on)
+        syncComponents({
+            presets,
+            specifiedComponents: [...local, ...external],
+        });
+    }
+};
+export const syncAllComponents = ({ presets }) => {
+    // #1: discover all external .sb.js files
+    const allLocalSbComponentsSchemaFiles = discover({
+        scope: SCOPE.local,
+        type: LOOKUP_TYPE.fileName,
+    });
+    // #2: discover all local .sb.js files
+    const allExternalSbComponentsSchemaFiles = discover({
+        scope: SCOPE.external,
+        type: LOOKUP_TYPE.fileName,
+    });
+    // #3: compare results, prefare local ones (so we have to create final external paths array and local array of things to sync from where)
+    const { local, external } = compare({
+        local: allLocalSbComponentsSchemaFiles,
+        external: allExternalSbComponentsSchemaFiles,
+    });
+    // #4: sync - do all stuff already done (groups resolving, and so on)
+    syncComponents({
+        presets,
+        specifiedComponents: [...local, ...external],
+    });
+};

package/dist/api/mutateComponents.d.ts

@@ -0,0 +1,2 @@
+export declare const updateComponent: (component: any, presets: boolean) => void;
+export declare const createComponent: (component: any, presets: boolean) => void;

package/dist/api/mutateComponents.js

@@ -0,0 +1,45 @@
+import Logger from "../utils/logger.js";
+import storyblokConfig from "../config/config.js";
+import { sbApi } from "./config.js";
+import _resolvePresets from "./resolvePresets.js";
+const { spaceId } = storyblokConfig;
+// UPDATE
+export const updateComponent = (component, presets) => {
+    Logger.log(`Trying to update '${component.name}' with id ${component.id}`);
+    const componentWithPresets = component;
+    const { all_presets, ...componentWithoutPresets } = componentWithPresets;
+    sbApi
+        .put(`spaces/${spaceId}/components/${component.id}`, {
+        component: componentWithoutPresets,
+    })
+        .then((res) => {
+        Logger.success(`Component '${component.name}' has been updated.`);
+        if (presets) {
+            _resolvePresets(res, all_presets, component);
+        }
+    })
+        .catch((err) => {
+        Logger.error("error happened... :(");
+        console.log(`${err.message} in migration of ${component.name} in updateComponent function`);
+    });
+};
+// CREATE
+export const createComponent = (component, presets) => {
+    Logger.log(`Trying to create '${component.name}'`);
+    const componentWithPresets = component;
+    const { all_presets, ...componentWithoutPresets } = componentWithPresets;
+    sbApi
+        .post(`spaces/${spaceId}/components/`, {
+        component: componentWithoutPresets,
+    })
+        .then((res) => {
+        Logger.success(`Component '${component.name}' has been created.`);
+        if (presets) {
+            _resolvePresets(res, all_presets, component);
+        }
+    })
+        .catch((err) => {
+        Logger.error("error happened... :(");
+        console.log(`${err.message} in migration of ${component.name} in createComponent function`);
+    });
+};

package/dist/api/presets.d.ts

@@ -0,0 +1,4 @@
+export declare const getPreset: (presetId: string | undefined) => Promise<any>;
+export declare const getAllPresets: () => Promise<any>;
+export declare const createPreset: (p: any) => void;
+export declare const updatePreset: (p: any) => void;

package/dist/api/presets.js

@@ -0,0 +1,52 @@
+import Logger from "../utils/logger.js";
+import storyblokConfig from "../config/config.js";
+import { sbApi } from "./config.js";
+const { spaceId } = storyblokConfig;
+// GET
+export const getPreset = (presetId) => {
+    Logger.log(`Trying to get preset by id: ${presetId}`);
+    return sbApi
+        .get(`spaces/${spaceId}/presets/${presetId}`)
+        .then((response) => response.data)
+        .then((response) => {
+        if (Array.isArray(response.presets)) {
+            Logger.warning(`There is no preset for '${presetId}' preset id`);
+            return false;
+        }
+        return response;
+    })
+        .catch((err) => Logger.error(err));
+};
+export const getAllPresets = () => {
+    Logger.log("Trying to get all Presets.");
+    return sbApi
+        .get(`spaces/${spaceId}/presets/`)
+        .then((response) => response.data)
+        .catch((err) => Logger.error(err));
+};
+// CREATE
+export const createPreset = (p) => {
+    sbApi
+        .post(`spaces/${spaceId}/presets/`, {
+        preset: p.preset,
+    })
+        .then(() => {
+        Logger.warning(`Preset: '${p.preset.name}' has been created.`);
+    })
+        .catch(() => {
+        Logger.error(`Error happened. Preset: '${p.preset.name}' has been not created.`);
+    });
+};
+// UPDATE
+export const updatePreset = (p) => {
+    sbApi
+        .put(`spaces/${spaceId}/presets/${p.preset.id}`, {
+        preset: p.preset,
+    })
+        .then(() => {
+        Logger.warning(`Preset: '${p.preset.name}' with '${p.preset.id}' id has been updated.`);
+    })
+        .catch(() => {
+        Logger.error(`Error happened. Preset: '${p.preset.name}' with '${p.preset.id}' id has been not updated.`);
+    });
+};

package/dist/api/resolvePresets.d.ts

@@ -0,0 +1,2 @@
+declare const _resolvePresets: (res: any, all_presets: any, component: any) => Promise<void>;
+export default _resolvePresets;

package/dist/api/resolvePresets.js

@@ -0,0 +1,41 @@
+import Logger from "../utils/logger.js";
+import { updatePreset, createPreset } from "./presets.js";
+import { getComponentPresets } from "./componentPresets.js";
+const _resolvePresets = async (res, all_presets, component) => {
+    const componentId = res.data.component.id;
+    if (all_presets && all_presets.length > 0) {
+        const all_presets_modified = all_presets.map((p) => {
+            return { preset: { ...p.preset, component_id: componentId } };
+        });
+        Logger.log(`Checking preset for '${component.name}' component`);
+        const allRemoteComponentPresets = await getComponentPresets(component.name);
+        const presetsToUpdate = [];
+        const presetsToCreate = [];
+        for (const componentPreset of all_presets_modified) {
+            const shouldBeUpdated = allRemoteComponentPresets &&
+                allRemoteComponentPresets.find((remotePreset) => componentPreset.preset.name === remotePreset.preset.name);
+            if (shouldBeUpdated) {
+                presetsToUpdate.push({
+                    ...componentPreset,
+                    preset: {
+                        id: shouldBeUpdated.preset.id,
+                        ...componentPreset.preset,
+                    },
+                });
+            }
+            else {
+                presetsToCreate.push(componentPreset);
+            }
+        }
+        presetsToUpdate.map((preset) => {
+            updatePreset(preset);
+        });
+        presetsToCreate.map((preset) => {
+            createPreset(preset);
+        });
+    }
+    else {
+        Logger.warning("There are no presets for this component.");
+    }
+};
+export default _resolvePresets;

package/dist/api/roles.d.ts

@@ -0,0 +1,14 @@
+import { OneComponent } from "../utils/discover.js";
+export declare const createRole: (role: any) => void;
+export declare const updateRole: (role: any) => void;
+export declare const getAllRoles: () => Promise<any>;
+export declare const getRole: (roleName: string | undefined) => Promise<any>;
+interface SyncRoles {
+    specifiedRoles: OneComponent[];
+}
+export declare const syncRoles: ({ specifiedRoles }: SyncRoles) => Promise<void>;
+export declare const syncAllRoles: () => Promise<void>;
+export declare const syncProvidedRoles: ({ roles }: {
+    roles: string[];
+}) => void;
+export {};