@openinc/parse-server-opendash 3.19.2 → 3.20.1

package/dist/featuremap.json

@@ -18,6 +18,7 @@
     "OD3_Dashboard": "MONITORING",
     "OD3_Documentation_Category": "DOCUMENTATION",
     "OD3_Documentation_Document": "DOCUMENTATION",
+    "OD3_Documentation_Config": "DOCUMENTATION",
     "OD3_GTFS_Agency": "GTFS",
     "OD3_GTFS_Bikes_Allowed": "GTFS",
     "OD3_GTFS_Calendar": "GTFS",

package/dist/features/config/helper/isFeatureEnabled.d.ts

@@ -1 +1,2 @@
-export declare function isFeatureEnabled(feature: string): boolean;
+export type Feature = "CORE" | "MONITORING" | "BDE" | "GTFS" | "KNOWLEDGE" | "MAINTENANCE" | "DOCUMENTATION" | "MIAAS";
+export declare function isFeatureEnabled(feature: Feature): boolean;

package/dist/features/documentation/config/defaults.d.ts

@@ -0,0 +1,39 @@
+import { FileConfig, FolderConfig, ImportOptions } from "../types";
+export declare const FOLDER_CONFIG_ALLOWED_KEYS: readonly ["title", "order", "icon", "files", "feature"];
+export type FolderConfigAllowedKey = (typeof FOLDER_CONFIG_ALLOWED_KEYS)[number];
+export declare const FILE_CONFIG_ALLOWED_KEYS: readonly ["order", "icon", "title", "locationPattern", "locations", "feature"];
+export type FileConfigAllowedKey = (typeof FILE_CONFIG_ALLOWED_KEYS)[number];
+/**
+ * Default configuration for documentation import
+ */
+export declare const DEFAULT_IMPORT_CONFIG: Partial<ImportOptions>;
+export declare const DEFAULT_FILE_CONFIG: Required<Pick<FileConfig, "order" | "icon">>;
+/**
+ * Preset configurations for different use cases
+ */
+export declare const IMPORT_PRESETS: {
+    DOCS_AND_CONFIG: {
+        includeExtensions: string[];
+        defaultFolderConfig: {
+            order: number;
+            icon: string;
+        };
+    };
+    MEDIA_ONLY: {
+        includeExtensions: string[];
+        defaultFolderConfig: {
+            template: string;
+            tags: string[];
+        };
+    };
+};
+/**
+ * Helper function to merge configuration
+ */
+export declare function createImportConfig(overrides?: Partial<ImportOptions>, preset?: keyof typeof IMPORT_PRESETS): ImportOptions;
+/**
+ * Sanitize a raw (parsed) folder config object by picking only allowed keys
+ * and recursively sanitizing file configs.
+ */
+export declare function sanitizeFolderConfig(raw: any): FolderConfig;
+export declare function sanitizeFileConfig(raw: any): FileConfig;

package/dist/features/documentation/config/defaults.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORT_PRESETS = exports.DEFAULT_FILE_CONFIG = exports.DEFAULT_IMPORT_CONFIG = exports.FILE_CONFIG_ALLOWED_KEYS = exports.FOLDER_CONFIG_ALLOWED_KEYS = void 0;
+exports.createImportConfig = createImportConfig;
+exports.sanitizeFolderConfig = sanitizeFolderConfig;
+exports.sanitizeFileConfig = sanitizeFileConfig;
+// ---------------------------------------------------------------------------
+// Allowed Config Keys (central source of truth)
+// ---------------------------------------------------------------------------
+exports.FOLDER_CONFIG_ALLOWED_KEYS = [
+    "title",
+    "order",
+    "icon",
+    "files",
+    "feature",
+];
+exports.FILE_CONFIG_ALLOWED_KEYS = [
+    "order",
+    "icon",
+    "title",
+    "locationPattern",
+    "locations",
+    "feature",
+];
+/**
+ * Default configuration for documentation import
+ */
+exports.DEFAULT_IMPORT_CONFIG = {
+    organization: "open-inc",
+    repository: "documentation",
+    branch: process.env.OI_DOCUMENTATION_GITHUB_BRANCH || "main",
+    rootPath: "docs", // Start from the docs folder
+    fileFilter: {
+        // Only include markdown and JSON files by default
+        includeExtensions: ["md", "json"],
+        // Exclude common non-documentation files
+        excludeExtensions: [],
+        // Path patterns (examples)
+        // includePaths: ["docs/**", "*.md"],
+        // excludePaths: ["node_modules/**", ".git/**", "**/.DS_Store"],
+    },
+    defaultFolderConfig: {
+        order: 999,
+    },
+};
+exports.DEFAULT_FILE_CONFIG = {
+    order: 999,
+    icon: "fa:file",
+};
+/**
+ * Preset configurations for different use cases
+ */
+exports.IMPORT_PRESETS = {
+    // Documentation + configuration
+    DOCS_AND_CONFIG: {
+        includeExtensions: ["md", "json"],
+        defaultFolderConfig: {
+            order: 999,
+            icon: "fa:folder",
+        },
+    },
+    // Media files
+    MEDIA_ONLY: {
+        includeExtensions: ["png", "jpg", "jpeg", "gif", "svg", "pdf"],
+        defaultFolderConfig: {
+            template: "media-gallery",
+            tags: ["media", "assets"],
+        },
+    },
+};
+/**
+ * Helper function to merge configuration
+ */
+function createImportConfig(overrides = {}, preset) {
+    const baseConfig = { ...exports.DEFAULT_IMPORT_CONFIG };
+    // Apply preset if provided
+    if (preset && exports.IMPORT_PRESETS[preset]) {
+        baseConfig.fileFilter = {
+            ...baseConfig.fileFilter,
+            ...exports.IMPORT_PRESETS[preset],
+        };
+        // Apply preset's default folder config if it exists
+        if (exports.IMPORT_PRESETS[preset].defaultFolderConfig) {
+            baseConfig.defaultFolderConfig = {
+                ...baseConfig.defaultFolderConfig,
+                ...exports.IMPORT_PRESETS[preset].defaultFolderConfig,
+            };
+        }
+    }
+    // Apply user overrides
+    const finalConfig = {
+        ...baseConfig,
+        ...overrides,
+        fileFilter: {
+            ...baseConfig.fileFilter,
+            ...overrides.fileFilter,
+        },
+        defaultFolderConfig: {
+            ...baseConfig.defaultFolderConfig,
+            ...overrides.defaultFolderConfig,
+        },
+    };
+    // Ensure required fields are present
+    if (!finalConfig.token) {
+        finalConfig.token = process.env.OI_DOCUMENTATION_GITHUB_ACCESS_TOKEN || "";
+    }
+    return finalConfig;
+}
+/**
+ * Sanitize a raw (parsed) folder config object by picking only allowed keys
+ * and recursively sanitizing file configs.
+ */
+function sanitizeFolderConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const folder = {};
+    for (const key of exports.FOLDER_CONFIG_ALLOWED_KEYS) {
+        if (key in raw) {
+            // files handled specially below
+            if (key !== "files")
+                folder[key] = raw[key];
+        }
+    }
+    if (raw.files && typeof raw.files === "object") {
+        const files = {};
+        for (const [base, cfg] of Object.entries(raw.files)) {
+            files[base] = sanitizeFileConfig(cfg);
+        }
+        folder.files = files;
+    }
+    return folder;
+}
+function sanitizeFileConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const fileCfg = {};
+    for (const key of exports.FILE_CONFIG_ALLOWED_KEYS) {
+        if (key in raw)
+            fileCfg[key] = raw[key];
+    }
+    return fileCfg;
+}

package/dist/features/documentation/config/index.d.ts

@@ -0,0 +1 @@
+export * from "./defaults";

package/dist/features/documentation/config/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./defaults"), exports);

package/dist/features/documentation/core/Cleanup.d.ts

@@ -0,0 +1,30 @@
+import { _User, Tenant } from "../../../types";
+import { DocumentationStructure } from "../types";
+/**
+ * Service for cleaning up old documentation that no longer exists in the repository
+ */
+export declare class DocumentationCleanup {
+    /**
+     * Remove old default documentation that is no longer present in the new import
+     */
+    static cleanupOldDocumentation(newStructure: DocumentationStructure, user: _User | undefined, tenant: Tenant | undefined): Promise<{
+        deletedDocuments: number;
+        deletedCategories: number;
+    }>;
+    /**
+     * Collect all git paths from the documentation structure
+     */
+    private static collectGitPaths;
+    /**
+     * Recursively collect folder paths
+     */
+    private static collectFolderPaths;
+    /**
+     * Find all existing default documents for the given user/tenant
+     */
+    private static findExistingDefaultDocuments;
+    /**
+     * Find all existing default categories for the given user/tenant
+     */
+    private static findExistingDefaultCategories;
+}

package/dist/features/documentation/core/Cleanup.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationCleanup = void 0;
+const types_1 = require("../../../types");
+/**
+ * Service for cleaning up old documentation that no longer exists in the repository
+ */
+class DocumentationCleanup {
+    /**
+     * Remove old default documentation that is no longer present in the new import
+     */
+    static async cleanupOldDocumentation(newStructure, user, tenant) {
+        console.log(`[DocumentationCleanup] Starting cleanup of old default documentation`);
+        // Collect all new git paths from the structure
+        const newGitPaths = new Set();
+        this.collectGitPaths(newStructure, newGitPaths);
+        console.log(`[DocumentationCleanup] Found ${newGitPaths.size} current git paths`);
+        // Find all existing default documentation for this user/tenant
+        const existingDocuments = await this.findExistingDefaultDocuments(user, tenant);
+        const existingCategories = await this.findExistingDefaultCategories(user, tenant);
+        console.log(`[DocumentationCleanup] Found ${existingDocuments.length} existing documents and ${existingCategories.length} existing categories`);
+        // Identify documents to delete
+        const documentsToDelete = existingDocuments.filter((doc) => {
+            const gitPath = doc.get("gitPath");
+            return gitPath && !newGitPaths.has(gitPath);
+        });
+        // Identify categories to delete
+        const categoriesToDelete = existingCategories.filter((cat) => {
+            const gitPath = cat.get("gitPath");
+            return gitPath && !newGitPaths.has(gitPath);
+        });
+        console.log(`[DocumentationCleanup] Identified ${documentsToDelete.length} documents and ${categoriesToDelete.length} categories for deletion`);
+        // Delete old documents
+        let deletedDocuments = 0;
+        for (const doc of documentsToDelete) {
+            try {
+                console.log(`[DocumentationCleanup] Deleting document: ${doc.get("title")} (gitPath: ${doc.get("gitPath")})`);
+                await doc.destroy({ useMasterKey: true });
+                deletedDocuments++;
+            }
+            catch (error) {
+                console.error(`[DocumentationCleanup] Failed to delete document ${doc.id}:`, error);
+            }
+        }
+        // Delete old categories (delete in reverse order to handle parent-child relationships)
+        let deletedCategories = 0;
+        const sortedCategories = categoriesToDelete.sort((a, b) => {
+            // Sort by gitPath depth (deeper paths first) to delete children before parents
+            const aDepth = (a.get("gitPath") || "").split("/").length;
+            const bDepth = (b.get("gitPath") || "").split("/").length;
+            return bDepth - aDepth;
+        });
+        for (const cat of sortedCategories) {
+            try {
+                console.log(`[DocumentationCleanup] Deleting category: ${cat.get("name")} (gitPath: ${cat.get("gitPath")})`);
+                await cat.destroy({ useMasterKey: true });
+                deletedCategories++;
+            }
+            catch (error) {
+                console.error(`[DocumentationCleanup] Failed to delete category ${cat.id}:`, error);
+            }
+        }
+        console.log(`[DocumentationCleanup] Cleanup complete: deleted ${deletedDocuments} documents and ${deletedCategories} categories`);
+        return { deletedDocuments, deletedCategories };
+    }
+    /**
+     * Collect all git paths from the documentation structure
+     */
+    static collectGitPaths(structure, gitPaths) {
+        // Collect file paths
+        for (const file of structure.allFiles) {
+            gitPaths.add(file.path);
+        }
+        // Collect folder paths recursively
+        this.collectFolderPaths(structure.root, "", gitPaths);
+    }
+    /**
+     * Recursively collect folder paths
+     */
+    static collectFolderPaths(folder, currentPath, gitPaths) {
+        // Add current folder path (except root)
+        if (currentPath) {
+            gitPaths.add(currentPath);
+        }
+        // Recursively process subfolders
+        for (const [name, subfolder] of folder.subfolders) {
+            const subfolderPath = currentPath ? `${currentPath}/${name}` : name;
+            this.collectFolderPaths(subfolder, subfolderPath, gitPaths);
+        }
+    }
+    /**
+     * Find all existing default documents for the given user/tenant
+     */
+    static async findExistingDefaultDocuments(user, tenant) {
+        const query = new Parse.Query(types_1.Documentation_Document)
+            .equalTo("isDefault", true)
+            .exists("gitPath"); // Only documents with gitPath (from repository)
+        if (tenant) {
+            query.equalTo("tenant", tenant);
+        }
+        if (user) {
+            query.equalTo("user", user);
+        }
+        try {
+            return await query.find({ useMasterKey: true });
+        }
+        catch (error) {
+            console.error(`[DocumentationCleanup] Failed to query existing documents:`, error);
+            return [];
+        }
+    }
+    /**
+     * Find all existing default categories for the given user/tenant
+     */
+    static async findExistingDefaultCategories(user, tenant) {
+        const query = new Parse.Query(types_1.Documentation_Category)
+            .equalTo("isDefault", true)
+            .exists("gitPath"); // Only categories with gitPath (from repository)
+        if (tenant) {
+            query.equalTo("tenant", tenant);
+        }
+        if (user) {
+            query.equalTo("user", user);
+        }
+        try {
+            return await query.find({ useMasterKey: true });
+        }
+        catch (error) {
+            console.error(`[DocumentationCleanup] Failed to query existing categories:`, error);
+            return [];
+        }
+    }
+}
+exports.DocumentationCleanup = DocumentationCleanup;

package/dist/features/documentation/core/Converter.d.ts

@@ -0,0 +1,9 @@
+import { _User, Tenant } from "../../../types";
+import { ImportResult } from "../types";
+export declare class DocumentationConverter {
+    private readonly results;
+    constructor(importResults: ImportResult);
+    convert(user?: _User, tenant?: Tenant): Promise<void>;
+    private convertFolderToCategory;
+    private convertFileToDocumentation;
+}

package/dist/features/documentation/core/Converter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationConverter = void 0;
+const types_1 = require("../../../types");
+const USER_ID = process.env.OI_DOCUMENTATION_USER_ID;
+const TENANT_ID = process.env.OI_DOCUMENTATION_TENANT_ID;
+class DocumentationConverter {
+    constructor(importResults) {
+        this.results = importResults;
+    }
+    async convert(user, tenant) {
+        // Implement your conversion logic here
+        if (!this.results.structure)
+            return;
+        this.convertFolderToCategory(this.results.structure.root, undefined, user, tenant);
+    }
+    async convertFolderToCategory(folder, parentCategory, user, tenant) {
+        const existingCategory = await new Parse.Query(types_1.Documentation_Category)
+            .equalTo("gitPath", folder.path)
+            .equalTo("isDefault", true)
+            .equalTo("user", user)
+            .equalTo("tenant", tenant)
+            .first({ useMasterKey: true });
+        const folderCategory = existingCategory || new types_1.Documentation_Category();
+        folderCategory.set("name", folder.config.title || folder.name);
+        folderCategory.set("icon", folder.config.icon);
+        folderCategory.set("order", folder.config.order || 999);
+        folderCategory.set("parent", parentCategory);
+        folderCategory.set("isDefault", true);
+        folderCategory.set("gitPath", folder.path);
+        if (user)
+            folderCategory.set("user", user);
+        if (tenant || user)
+            folderCategory.set("tenant", tenant ?? user?.get("tenant"));
+        const savedCategory = await folderCategory.save(null, {
+            useMasterKey: true,
+        });
+        for (const subfolder of folder.subfolders.values())
+            await this.convertFolderToCategory(subfolder, savedCategory, user, tenant);
+        for (const file of folder.files)
+            await this.convertFileToDocumentation(file, savedCategory, user, tenant);
+    }
+    async convertFileToDocumentation(file, category, user, tenant) {
+        const existingDoc = await new Parse.Query(types_1.Documentation_Document)
+            .equalTo("gitPath", file.path)
+            .equalTo("isDefault", true)
+            .first({ useMasterKey: true });
+        const doc = existingDoc || new types_1.Documentation_Document();
+        doc.set("title", file.config?.title || file.name);
+        doc.set("content", file.content || "");
+        doc.set("icon", file.config?.icon);
+        doc.set("order", file.config?.order || 999);
+        doc.set("category", category);
+        doc.set("locationPattern", file.config?.locationPattern);
+        doc.set("locations", file.config?.locations || []);
+        doc.set("isDefault", true);
+        doc.set("gitPath", file.path);
+        if (user)
+            doc.set("user", user);
+        if (tenant || user)
+            doc.set("tenant", tenant ?? user?.get("tenant"));
+        await doc.save(null, { useMasterKey: true });
+    }
+}
+exports.DocumentationConverter = DocumentationConverter;

package/dist/features/documentation/core/Importer.d.ts

@@ -0,0 +1,21 @@
+import { ImportOptions, ImportResult } from "../types";
+import { _User, Tenant } from "../../../types";
+/**
+ * Main Documentation Importer class
+ */
+export declare class DocumentationImporter {
+    private githubClient;
+    constructor(token: string);
+    /**
+     * Import documentation from a GitHub repository
+     */
+    importFromRepository(options: ImportOptions, user: _User | undefined, tenant: Tenant | undefined): Promise<ImportResult>;
+    /**
+     * Validate that a branch exists
+     */
+    private validateBranch;
+    /**
+     * Get file content from GitHub
+     */
+    getFileContent(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+}

package/dist/features/documentation/core/Importer.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationImporter = void 0;
+const services_1 = require("../services");
+const types_1 = require("../../../types");
+const Organizer_1 = require("./Organizer");
+const Cleanup_1 = require("./Cleanup");
+/**
+ * Main Documentation Importer class
+ */
+class DocumentationImporter {
+    constructor(token) {
+        this.githubClient = new services_1.GitHubClient(token);
+    }
+    /**
+     * Import documentation from a GitHub repository
+     */
+    async importFromRepository(options, user, tenant) {
+        // Validate token
+        const gitUser = await this.githubClient.validateToken();
+        // Get repository info
+        const repo = await this.githubClient.getRepository(options.organization, options.repository);
+        // Determine branch to use
+        const branch = options.branch || repo.default_branch;
+        // Validate branch exists
+        await this.validateBranch(options.organization, options.repository, branch);
+        // Get branch info (commit SHA)
+        const branchInfo = await this.githubClient.getBranch(options.organization, options.repository, branch);
+        const latestCommitSha = branchInfo.commit.sha;
+        // Attempt to load previously imported commit SHA from Parse
+        let previousCommitSha;
+        let stateObj;
+        try {
+            stateObj = await new Parse.Query(types_1.Documentation_Config)
+                .equalTo("tenant", tenant)
+                .equalTo("user", user)
+                .first({
+                useMasterKey: true,
+            });
+            previousCommitSha = stateObj?.get("lastCommitSha");
+        }
+        catch (err) {
+            console.log(`Could not load previous commit SHA: ${err.message}`);
+        }
+        // Early exit if unchanged
+        if (previousCommitSha && previousCommitSha === latestCommitSha) {
+            return {
+                metadata: {
+                    totalFiles: 0,
+                    fileTypes: [],
+                    // importedAt still reflects the check time
+                    importedAt: new Date(),
+                    repository: `${options.organization}/${options.repository}`,
+                    branch,
+                    commitSha: latestCommitSha,
+                    previousCommitSha,
+                    skipped: true,
+                    skipReason: "unchanged",
+                },
+            };
+        }
+        const treeData = await this.githubClient.getTree(options.organization, options.repository, latestCommitSha);
+        // Organize structure with filtering and root path
+        const structure = await Organizer_1.DocumentationOrganizer.organizeRepositoryStructure(treeData, options.fileFilter, options.rootPath, this.githubClient, options.organization, options.repository, branch, options.defaultFolderConfig);
+        // Clean up old documentation that is no longer in the repository
+        // This only runs when commit SHA has changed (not on first import when previousCommitSha is undefined)
+        let cleanupResult = { deletedDocuments: 0, deletedCategories: 0 };
+        if (previousCommitSha) {
+            console.log(`[DocumentationImporter] Repository content changed, cleaning up old documentation...`);
+            try {
+                cleanupResult = await Cleanup_1.DocumentationCleanup.cleanupOldDocumentation(structure, user, tenant);
+                console.log(`[DocumentationImporter] Cleanup completed: ${cleanupResult.deletedDocuments} documents and ${cleanupResult.deletedCategories} categories removed`);
+            }
+            catch (error) {
+                console.error(`[DocumentationImporter] Cleanup failed:`, error);
+                // Continue with import even if cleanup fails
+            }
+        }
+        else {
+            console.log(`[DocumentationImporter] First import detected, skipping cleanup`);
+        }
+        // Persist latest commit SHA for future runs
+        try {
+            if (!stateObj) {
+                stateObj = new types_1.Documentation_Config();
+            }
+            stateObj.set("lastCommitSha", latestCommitSha);
+            if (tenant)
+                stateObj.set("tenant", tenant);
+            if (user)
+                stateObj.set("user", user);
+            await stateObj.save(null, { useMasterKey: true });
+        }
+        catch (err) {
+            console.log(`Could not persist latest commit SHA: ${err.message}`);
+        }
+        return {
+            structure,
+            metadata: {
+                totalFiles: structure.allFiles.length,
+                fileTypes: Array.from(structure.filesByExtension.keys()),
+                importedAt: new Date(),
+                repository: `${options.organization}/${options.repository}`,
+                branch,
+                commitSha: latestCommitSha,
+                previousCommitSha,
+                cleanup: cleanupResult,
+            },
+        };
+    }
+    /**
+     * Validate that a branch exists
+     */
+    async validateBranch(owner, repo, branch) {
+        try {
+            const branches = await this.githubClient.getBranches(owner, repo);
+            const branchNames = branches.map((b) => b.name);
+            if (!branchNames.includes(branch)) {
+                throw new Error(`Branch '${branch}' not found. Available branches: ${branchNames.join(", ")}`);
+            }
+        }
+        catch (error) {
+            console.log(`Could not validate branches: ${error}`);
+        }
+    }
+    /**
+     * Get file content from GitHub
+     */
+    async getFileContent(owner, repo, path, ref) {
+        return this.githubClient.getFileContent(owner, repo, path, ref);
+    }
+}
+exports.DocumentationImporter = DocumentationImporter;

package/dist/features/documentation/core/Organizer.d.ts

@@ -0,0 +1,11 @@
+import { GitHubTreeResponse, DocumentationStructure, FileFilterOptions, FolderConfig } from "../types";
+import { GitHubClient } from "../services/GitHubClient";
+/**
+ * Documentation Structure Organizer
+ */
+export declare class DocumentationOrganizer {
+    /**
+     * Organize GitHub tree data into a hierarchical structure
+     */
+    static organizeRepositoryStructure(treeData: GitHubTreeResponse, fileFilter?: FileFilterOptions, rootPath?: string, githubClient?: GitHubClient, owner?: string, repo?: string, branch?: string, defaultFolderConfig?: Partial<FolderConfig>): Promise<DocumentationStructure>;
+}