How to use the vscode-azureextensionui.registerCommand function in vscode-azureextensionui

vscode.workspace.onDidSaveTextDocument,
            async function (this: IActionContext, document: vscode.TextDocument): Promise {
                await integrationAccountPartnerEditor.onDidSaveTextDocument(this, context.globalState, document);
            });

        registerEvent("azIntegrationAccounts.integrationAccountSchemaEditor.onDidSaveTextDocument",
            vscode.workspace.onDidSaveTextDocument,
            async function (this: IActionContext, document: vscode.TextDocument): Promise {
                await integrationAccountSchemaEditor.onDidSaveTextDocument(this, context.globalState, document);
            });

        registerCommand("azIntegrationAccounts.openAgreementInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountAgreementInEditor(integrationAccountTree, integrationAccountAgreementEditor, node);
        });

        registerCommand("azIntegrationAccounts.openMapInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountMapInEditor(integrationAccountTree, integrationAccountMapEditor, node);
        });

        registerCommand("azIntegrationAccounts.openPartnerInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountPartnerInEditor(integrationAccountTree, integrationAccountPartnerEditor, node);
        });

        registerCommand("azIntegrationAccounts.openSchemaInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountSchemaInEditor(integrationAccountTree, integrationAccountSchemaEditor, node);
        });

        registerCommand("azIntegrationAccounts.refresh", async (node?: IAzureNode) => {
            await integrationAccountTree.refresh(node);
        });

        registerCommand("azIntegrationAccounts.selectSubscriptions", () => {

function activateDps(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel) {
    let dpsTreeItem = new DpsAccountTreeItem();
    let dpsExtTreeDataProvider = new AzExtTreeDataProvider(dpsTreeItem, "azure-iot-dps.loadMore");

    context.subscriptions.push(dpsTreeItem);
    context.subscriptions.push(vscode.window.createTreeView("iotDpsExplorer", { treeDataProvider: dpsExtTreeDataProvider, showCollapseAll: true }));

    let azureDpsExplorer = new AzureDpsExplorer(outputChannel, dpsExtTreeDataProvider);

    registerCommand("azure-iot-dps.viewProperties", async (actionContext: IActionContext, node?: DpsResourceTreeItem) => {
        await azureDpsExplorer.viewProperties(actionContext, node);
    });
    registerCommand("azure-iot-dps.loadMore", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.loadMore(actionContext, node);
    });
    registerCommand("azure-iot-dps.refresh", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.refresh(actionContext, node);
    });
}

await openIntegrationAccountMapInEditor(integrationAccountTree, integrationAccountMapEditor, node);
        });

        registerCommand("azIntegrationAccounts.openPartnerInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountPartnerInEditor(integrationAccountTree, integrationAccountPartnerEditor, node);
        });

        registerCommand("azIntegrationAccounts.openSchemaInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountSchemaInEditor(integrationAccountTree, integrationAccountSchemaEditor, node);
        });

        registerCommand("azIntegrationAccounts.refresh", async (node?: IAzureNode) => {
            await integrationAccountTree.refresh(node);
        });

        registerCommand("azIntegrationAccounts.selectSubscriptions", () => {
            vscode.commands.executeCommand("azure-account.selectSubscriptions");
        });

        registerCommand("azIntegrationAccounts.viewAgreementProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountAgreementProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewMapProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountMapProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewPartnerProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountPartnerProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewSchemaProperties", async (node?: IAzureNode) => {

await openVersionInDesigner(tree, node);
        });

        registerCommand("azureLogicApps.openVersionInEditor", async (node?: IAzureNode) => {
            await openVersionInEditor(tree, node);
        });

        registerCommand("azureLogicApps.promoteVersion", async (node?: IAzureNode) => {
            await promoteVersion(tree, node);
        });

        registerCommand("azureLogicApps.refresh", async (node?: IAzureNode) => {
            await tree.refresh(node);
        });

        registerCommand("azureLogicApps.resubmitRun", async (node?: IAzureNode) => {
            await resubmitRun(tree, node);
        });

        registerCommand("azureLogicApps.runTrigger", async (node?: IAzureNode) => {
            await runTrigger(tree, node);
        });

        registerCommand("azureLogicApps.selectSubscriptions", () => {
            vscode.commands.executeCommand("azure-account.selectSubscriptions");
        });

        registerEvent(
            "azureLogicApps.logicAppEditor.onDidSaveTextDocument",
            vscode.workspace.onDidSaveTextDocument,
            async function (this: IActionContext, document: vscode.TextDocument): Promise {
                await logicAppEditor.onDidSaveTextDocument(this, context.globalState, document);

function activateDps(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel) {
    let dpsTreeItem = new DpsAccountTreeItem();
    let dpsExtTreeDataProvider = new AzExtTreeDataProvider(dpsTreeItem, "azure-iot-dps.loadMore");

    context.subscriptions.push(dpsTreeItem);
    context.subscriptions.push(vscode.window.createTreeView("iotDpsExplorer", { treeDataProvider: dpsExtTreeDataProvider, showCollapseAll: true }));

    let azureDpsExplorer = new AzureDpsExplorer(outputChannel, dpsExtTreeDataProvider);

    registerCommand("azure-iot-dps.viewProperties", async (actionContext: IActionContext, node?: DpsResourceTreeItem) => {
        await azureDpsExplorer.viewProperties(actionContext, node);
    });
    registerCommand("azure-iot-dps.loadMore", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.loadMore(actionContext, node);
    });
    registerCommand("azure-iot-dps.refresh", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.refresh(actionContext, node);
    });
}

await deleteLogicApp(tree, node);
        });

        registerCommand("azureLogicApps.disableLogicApp", async (node: IAzureNode) => {
            await disableLogicApp(tree, node);
        });

        registerCommand("azureLogicApps.enableLogicApp", async (node: IAzureNode) => {
            await enableLogicApp(tree, node);
        });

        registerCommand("azureLogicApps.loadMore", async (node: IAzureNode) => {
            await tree.loadMore(node);
        });

        registerCommand("azureLogicApps.openInDesigner", async (node?: IAzureNode) => {
            await openInDesigner(tree, node);
        });

        registerCommand("azureLogicApps.openInEditor", async (node?: IAzureNode) => {
            await openInEditor(tree, logicAppEditor, node);
        });

        registerCommand("azureLogicApps.openInPortal", async (node?: IAzureNode) => {
            await openInPortal(tree, node);
        });

        registerCommand("azureLogicApps.openRunActionInEditor", async (node?: IAzureNode) => {
            await openRunActionInEditor(tree, node);
        });

        registerCommand("azureLogicApps.openRunInEditor", async (node?: IAzureNode) => {

registerCommand("azIntegrationAccounts.createPartner", async (node?: IAzureParentNode) => {
            const child = await createChildNode(integrationAccountTree, IntegrationAccountPartnersTreeItem.contextValue, node);
            await openIntegrationAccountPartnerInEditor(integrationAccountTree, integrationAccountPartnerEditor, child);
        });

        registerCommand("azIntegrationAccounts.createSchema", async (node?: IAzureParentNode) => {
            const child = await createChildNode(integrationAccountTree, IntegrationAccountSchemasTreeItem.contextValue, node);
            await openIntegrationAccountSchemaInEditor(integrationAccountTree, integrationAccountSchemaEditor, child);
        });

        registerCommand("azIntegrationAccounts.deleteIntegrationAccount", async (node: IAzureNode) => {
            await deleteIntegrationAccount(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.deleteAgreement", async (node: IAzureNode) => {
            await deleteIntegrationAccountAgreement(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.deleteMap", async (node: IAzureNode) => {
            await deleteIntegrationAccountMap(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.deletePartner", async (node: IAzureNode) => {
            await deleteIntegrationAccountPartner(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.deleteSchema", async (node: IAzureNode) => {
            await deleteIntegrationAccountSchema(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.loadMore", async (node: IAzureNode) => {

vscode.commands.executeCommand("azure-account.selectSubscriptions");
        });

        registerCommand("azIntegrationAccounts.viewAgreementProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountAgreementProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewMapProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountMapProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewPartnerProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountPartnerProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewSchemaProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountSchemaProperties(integrationAccountTree, node);
        });

        registerCommand("azIntegrationAccounts.viewIntegrationAccountProperties", async (node?: IAzureNode) => {
            await viewIntegrationAccountProperties(integrationAccountTree, node);
        });
    });
}

await integrationAccountMapEditor.onDidSaveTextDocument(this, context.globalState, document);
            });

        registerEvent("azIntegrationAccounts.integrationAccountPartnerEditor.onDidSaveTextDocument",
            vscode.workspace.onDidSaveTextDocument,
            async function (this: IActionContext, document: vscode.TextDocument): Promise {
                await integrationAccountPartnerEditor.onDidSaveTextDocument(this, context.globalState, document);
            });

        registerEvent("azIntegrationAccounts.integrationAccountSchemaEditor.onDidSaveTextDocument",
            vscode.workspace.onDidSaveTextDocument,
            async function (this: IActionContext, document: vscode.TextDocument): Promise {
                await integrationAccountSchemaEditor.onDidSaveTextDocument(this, context.globalState, document);
            });

        registerCommand("azIntegrationAccounts.openAgreementInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountAgreementInEditor(integrationAccountTree, integrationAccountAgreementEditor, node);
        });

        registerCommand("azIntegrationAccounts.openMapInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountMapInEditor(integrationAccountTree, integrationAccountMapEditor, node);
        });

        registerCommand("azIntegrationAccounts.openPartnerInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountPartnerInEditor(integrationAccountTree, integrationAccountPartnerEditor, node);
        });

        registerCommand("azIntegrationAccounts.openSchemaInEditor", async (node?: IAzureNode) => {
            await openIntegrationAccountSchemaInEditor(integrationAccountTree, integrationAccountSchemaEditor, node);
        });

        registerCommand("azIntegrationAccounts.refresh", async (node?: IAzureNode) => {

function activateDps(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel) {
    let dpsTreeItem = new DpsAccountTreeItem();
    let dpsExtTreeDataProvider = new AzExtTreeDataProvider(dpsTreeItem, "azure-iot-dps.loadMore");

    context.subscriptions.push(dpsTreeItem);
    context.subscriptions.push(vscode.window.createTreeView("iotDpsExplorer", { treeDataProvider: dpsExtTreeDataProvider, showCollapseAll: true }));

    let azureDpsExplorer = new AzureDpsExplorer(outputChannel, dpsExtTreeDataProvider);

    registerCommand("azure-iot-dps.viewProperties", async (actionContext: IActionContext, node?: DpsResourceTreeItem) => {
        await azureDpsExplorer.viewProperties(actionContext, node);
    });
    registerCommand("azure-iot-dps.loadMore", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.loadMore(actionContext, node);
    });
    registerCommand("azure-iot-dps.refresh", async (actionContext: IActionContext, node: AzureTreeItem) => {
        await azureDpsExplorer.refresh(actionContext, node);
    });
}