@mdfriday/foundry 26.2.12 → 26.3.1

package/dist/internal/domain/publish/type.d.ts

@@ -0,0 +1,59 @@
+export type PublishType = 'ftp' | 'netlify' | 'mdfriday';
+export interface PublishProgressInfo {
+    phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
+    percentage: number;
+    message: string;
+    currentFile?: string;
+    filesCompleted?: number;
+    filesTotal?: number;
+    bytesTransferred?: number;
+    bytesTotal?: number;
+}
+export type PublishProgressCallback = (progress: PublishProgressInfo) => void;
+export interface PublishResult {
+    success: boolean;
+    url?: string;
+    filesUploaded: number;
+    bytesTransferred: number;
+    duration: number;
+    error?: string;
+}
+export interface BasePublishConfig {
+    type: PublishType;
+}
+export interface FtpPublishConfig extends BasePublishConfig {
+    type: 'ftp';
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    remotePath: string;
+    secure: boolean;
+}
+export interface NetlifyPublishConfig extends BasePublishConfig {
+    type: 'netlify';
+    accessToken: string;
+    siteId: string;
+}
+export interface MDFridayPublishConfig extends BasePublishConfig {
+    type: 'mdfriday';
+    apiUrl?: string;
+    deploymentType: 'share' | 'sub' | 'custom' | 'enterprise';
+    enabled: boolean;
+    accessToken?: string;
+    licenseKey?: string;
+}
+export type AnyPublishConfig = FtpPublishConfig | NetlifyPublishConfig | MDFridayPublishConfig;
+export interface Publisher {
+    publish(sourceDir: string, options?: {
+        incremental?: boolean;
+        force?: boolean;
+        onProgress?: PublishProgressCallback;
+    }): Promise<PublishResult>;
+    testConnection?(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getConfig(): AnyPublishConfig;
+    getType(): PublishType;
+}

package/dist/internal/domain/publish/value-object/ftp-publisher.d.ts

@@ -0,0 +1,22 @@
+import { Publisher, PublishType, FtpPublishConfig, PublishResult, PublishProgressCallback } from '../type';
+import { ManifestRepository } from '../repository/manifest-repository';
+export declare class FtpPublisher implements Publisher {
+    private readonly config;
+    private readonly manifestRepo;
+    private readonly projectId;
+    private readonly projectPath;
+    constructor(config: FtpPublishConfig, manifestRepo: ManifestRepository, projectId: string, projectPath: string);
+    publish(sourceDir: string, options?: {
+        incremental?: boolean;
+        onProgress?: PublishProgressCallback;
+    }): Promise<PublishResult>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getConfig(): FtpPublishConfig;
+    getType(): PublishType;
+    private connectWithFallback;
+    private uploadFileWithRetry;
+    private getFileLists;
+}

package/dist/internal/domain/publish/value-object/mdfriday-publisher.d.ts

@@ -0,0 +1,28 @@
+import { Publisher, PublishType, MDFridayPublishConfig, PublishResult, PublishProgressCallback } from '../type';
+import { ManifestRepository } from '../repository/manifest-repository';
+import { HttpClient } from '../repository/http-client';
+export declare class MDFridayPublisher implements Publisher {
+    private readonly config;
+    private readonly manifestRepo;
+    private readonly httpClient;
+    private readonly projectId;
+    private readonly projectPath;
+    constructor(config: MDFridayPublishConfig, manifestRepo: ManifestRepository, httpClient: HttpClient, projectId: string, projectPath: string);
+    publish(sourceDir: string, options?: {
+        incremental?: boolean;
+        onProgress?: PublishProgressCallback;
+    }): Promise<PublishResult>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getConfig(): MDFridayPublishConfig;
+    getType(): PublishType;
+    private createZipFromDirectory;
+    private uploadToMDFriday;
+    private deployPreview;
+    private buildFormData;
+    private getApiUrl;
+    private simulateUploadProgress;
+    private formatBytes;
+}

package/dist/internal/domain/publish/value-object/netlify-publisher.d.ts

@@ -0,0 +1,28 @@
+import { Publisher, PublishType, NetlifyPublishConfig, PublishResult, PublishProgressCallback } from '../type';
+import { ManifestRepository } from '../repository/manifest-repository';
+import { HttpClient } from '../repository/http-client';
+export declare class NetlifyPublisher implements Publisher {
+    private readonly config;
+    private readonly manifestRepo;
+    private readonly httpClient;
+    private readonly projectId;
+    private readonly projectPath;
+    constructor(config: NetlifyPublishConfig, manifestRepo: ManifestRepository, httpClient: HttpClient, projectId: string, projectPath: string);
+    publish(sourceDir: string, options?: {
+        incremental?: boolean;
+        onProgress?: PublishProgressCallback;
+    }): Promise<PublishResult>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getConfig(): NetlifyPublishConfig;
+    getType(): PublishType;
+    private getFileLists;
+    private createDeployWithDigests;
+    private uploadRequiredFiles;
+    private uploadFileWithRetry;
+    private waitForDeployment;
+    private getSiteUrl;
+    private formatBytes;
+}

package/dist/internal/domain/publish/value-object/publish-config.d.ts

@@ -0,0 +1,36 @@
+export interface FTPConfig {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    remotePath: string;
+    secure: boolean;
+}
+export interface NetlifyConfig {
+    accessToken: string;
+    siteId: string;
+}
+export interface MDFridayConfig {
+    enabled: boolean;
+    type: 'share' | 'sub' | 'custom' | 'enterprise';
+    autoPublish: boolean;
+    licenseKey?: string;
+}
+export declare class WorkspacePublishConfig {
+    readonly ftp?: FTPConfig;
+    readonly netlify?: NetlifyConfig;
+    readonly mdfriday?: MDFridayConfig;
+    constructor(data: {
+        ftp?: FTPConfig;
+        netlify?: NetlifyConfig;
+        mdfriday?: MDFridayConfig;
+    });
+    hasFTP(): boolean;
+    hasNetlify(): boolean;
+    hasMDFriday(): boolean;
+    getFTPConfig(): FTPConfig | null;
+    getNetlifyConfig(): NetlifyConfig | null;
+    getMDFridayConfig(): MDFridayConfig | null;
+    static fromGlobalConfig(globalConfig: any): WorkspacePublishConfig;
+    merge(override: Partial<FTPConfig | NetlifyConfig | MDFridayConfig>, method: 'ftp' | 'netlify' | 'mdfriday'): WorkspacePublishConfig;
+}

package/dist/internal/domain/publish/value-object/publish-manifest.d.ts

@@ -0,0 +1,38 @@
+export interface ManifestFileEntry {
+    hash: string;
+    size: number;
+    mtime: number;
+    relativePath: string;
+}
+export declare class PublishManifest {
+    private readonly projectId;
+    private readonly publishMethod;
+    private readonly lastPublishTime;
+    private readonly files;
+    private readonly remoteConfig?;
+    constructor(data: {
+        projectId: string;
+        publishMethod: 'ftp' | 'netlify' | 'mdfriday';
+        lastPublishTime: number;
+        files: Map<string, ManifestFileEntry> | Record<string, ManifestFileEntry>;
+        remoteConfig?: any;
+    });
+    getProjectId(): string;
+    getPublishMethod(): string;
+    getLastPublishTime(): number;
+    getRemoteConfig(): any;
+    getAllFiles(): string[];
+    getFile(relativePath: string): ManifestFileEntry | undefined;
+    hasFile(relativePath: string): boolean;
+    getFileCount(): number;
+    getChangedFiles(newManifest: PublishManifest): string[];
+    getDeletedFiles(newManifest: PublishManifest): string[];
+    toJSON(): any;
+    static fromJSON(json: any): PublishManifest;
+    static create(data: {
+        projectId: string;
+        publishMethod: 'ftp' | 'netlify' | 'mdfriday';
+        files: Map<string, ManifestFileEntry> | Record<string, ManifestFileEntry>;
+        remoteConfig?: any;
+    }): PublishManifest;
+}

package/dist/internal/domain/site/entity/page.d.ts

@@ -14,7 +14,12 @@ export declare class Page implements ContentPage, PageMeta {
     private resources;
     private _paginator;
     private _processedContent;
+    private _precomputedData;
     constructor(tmplSvc: Template, langSvc: LanguageService, publisher: Publisher, contentPage: ContentPage, site: Site);
+    precomputeTemplateData(): Promise<void>;
+    private precomputeBacklinks;
+    private precomputeTableOfContents;
+    private precomputeSummary;
     processResources(pageSources: PageSource[]): Promise<void>;
     render(): Promise<void>;
     getPageOutput(): PageOutput;

package/dist/internal/domain/site/entity/pagegraph.d.ts

@@ -1,4 +1,4 @@
-import { LinkStrategy } from '../vo/path';
+import { LinkStrategy } from '../valueobject/path';
 export declare class PageGraph {
     private allSlugs;
     private outgoingLinks;

package/dist/internal/domain/site/entity/site.d.ts

@@ -30,6 +30,7 @@ export declare class Site {
     private title;
     private home;
     private pageGraph;
+    private backlinksCache;
     get Title(): string;
     get Description(): string;
     get Compiler(): Compiler;
@@ -100,5 +101,6 @@ export declare class Site {
     ProcessWikilinks(srcSlug: string, html: string): Promise<string>;
     getPageGraph(): PageGraph | null;
     GetBacklinks(targetSlug: string): string[];
+    buildBacklinksCache(pages: ContentPage[]): Promise<void>;
     GetContentIndex(): Promise<Map<string, any>>;
 }

package/dist/internal/domain/site/service/html-link-processor.d.ts

@@ -1,5 +1,5 @@
 import { PageGraph } from '../entity/pagegraph';
-import { LinkStrategy } from '../vo/path';
+import { LinkStrategy } from '../valueobject/path';
 export interface LinkProcessorOptions {
     markdownLinkResolution: LinkStrategy;
     prettyLinks: boolean;

package/dist/internal/domain/workspace/entity/authentication.d.ts

@@ -0,0 +1,11 @@
+export declare class Authentication {
+    private workspacePath;
+    private hasAuthFile;
+    constructor(workspacePath: string, hasAuthFile?: boolean);
+    getWorkspacePath(): string;
+    hasAuth(): boolean;
+    markAuthExists(): void;
+    markAuthDeleted(): void;
+    getAuthFilePath(): string;
+    getServerConfigPath(): string;
+}

package/dist/internal/domain/workspace/entity/project.d.ts

@@ -0,0 +1,77 @@
+import { ProjectMetadata } from '../value-object/project-metadata';
+import { BuildHistoryEntry } from '../type';
+export interface ProjectConfig {
+    baseURL?: string;
+    title?: string;
+    contentDir?: string;
+    publishDir?: string;
+    defaultContentLanguage?: string;
+    languages?: Record<string, {
+        contentDir?: string;
+        weight?: number;
+    }>;
+    [key: string]: any;
+}
+export declare class Project {
+    private metadata;
+    private projectPath;
+    private config;
+    constructor(projectPath: string, metadata: ProjectMetadata);
+    getPath(): string;
+    getMetadata(): ProjectMetadata;
+    getId(): string;
+    getName(): string;
+    getWorkspaceId(): string | undefined;
+    getBuildHistory(): BuildHistoryEntry[];
+    addBuildHistory(entry: BuildHistoryEntry): void;
+    getLastBuildTime(): number | undefined;
+    updateName(name: string): void;
+    loadConfig(): Promise<ProjectConfig>;
+    getConfig(): ProjectConfig | null;
+    getContentDirs(): Promise<string[]>;
+    getPublishDir(): Promise<string>;
+    getStaticDir(): string;
+    getDefaultLanguage(): Promise<string>;
+    getLanguages(): Promise<string[]>;
+    getConfigPath(): string;
+    getConfigValue(key: string): any;
+    setConfigValue(key: string, value: any): void;
+    unsetConfigValue(key: string): boolean;
+    saveConfig(): Promise<void>;
+    private getNestedValue;
+    private setNestedValue;
+    private deleteNestedValue;
+    getInfo(): {
+        id: string;
+        name: string;
+        path: string;
+        createdAt: Date;
+        updatedAt: Date;
+        lastBuild?: Date;
+        buildCount: number;
+    };
+    getSnapshotsDir(): string;
+    hasSourceLinks(): boolean;
+    getContentLinks(): Array<{
+        sourcePath: string;
+        languageCode: string;
+        weight: number;
+    }>;
+    getStaticLink(): {
+        sourcePath: string;
+    } | null;
+    setContentLinks(links: Array<{
+        sourcePath: string;
+        languageCode: string;
+        weight: number;
+    }>): void;
+    setStaticLink(link: {
+        sourcePath: string;
+    } | null): void;
+    addContentLink(sourcePath: string, languageCode: string, weight: number): void;
+    getDefaultContentSource(): string | null;
+    getAllContentSources(): string[];
+    getContentSourceByLanguage(languageCode: string): string | null;
+    getSupportedLanguagesFromLinks(): string[];
+    isLinkedProject(): boolean;
+}

package/dist/internal/domain/workspace/entity/workspace.d.ts

@@ -0,0 +1,49 @@
+import { WorkspaceMetadata } from '../value-object/workspace-metadata';
+import { ProjectRegistry } from '../type';
+import { Project } from './project';
+import { Authentication } from './authentication';
+export declare class Workspace {
+    private readonly rootPath;
+    private metadata;
+    private projects;
+    private authentication;
+    constructor(rootPath: string, metadata: WorkspaceMetadata, projects: Map<string, Project>, authentication: Authentication);
+    getPath(): string;
+    getMetadata(): WorkspaceMetadata;
+    getId(): string;
+    getName(): string;
+    getModulesDir(): string;
+    getProjectsDir(): string;
+    updateMetadata(updates: Parameters<WorkspaceMetadata['update']>[0]): void;
+    updateName(name: string): void;
+    getProjects(): Project[];
+    getProject(projectId: string): Project | undefined;
+    getProjectByName(name: string): Project | undefined;
+    findProject(idOrName: string): Project | undefined;
+    hasProject(projectId: string): boolean;
+    addProject(project: Project): void;
+    removeProject(projectId: string): Project | null;
+    getProjectCount(): number;
+    getProjectRegistry(): ProjectRegistry;
+    getAuthentication(): Authentication;
+    hasAuthentication(): boolean;
+    getConfigPath(): string;
+    getConfig(key: string): Promise<any>;
+    getAllConfig(): Promise<any>;
+    setConfig(key: string, value: any): Promise<void>;
+    unsetConfig(key: string): Promise<boolean>;
+    private getNestedValue;
+    private setNestedValue;
+    private deleteNestedValue;
+    getInfo(): {
+        id: string;
+        name: string;
+        path: string;
+        createdAt: Date;
+        updatedAt: Date;
+        modulesDir: string;
+        projectsDir: string;
+        projectCount: number;
+        hasAuth: boolean;
+    };
+}

package/dist/internal/domain/workspace/factory/workspace-factory.d.ts

@@ -0,0 +1,57 @@
+import { Workspace } from '../entity/workspace';
+import { Project } from '../entity/project';
+import { WorkspaceRepository, ProjectRepository, SnapshotRepository, FileSystemRepository } from '../repository';
+import { SnapshotMetadata } from '../type';
+import type { IdentityStorageProvider } from '@internal/domain/identity/repository/index';
+export interface WorkspaceFactoryOptions {
+    workspaceRepo: WorkspaceRepository;
+    projectRepo: ProjectRepository;
+    snapshotRepo: SnapshotRepository;
+    fileSystemRepo?: FileSystemRepository;
+}
+export declare class WorkspaceFactory {
+    private workspaceRepo;
+    private projectRepo;
+    private snapshotRepo;
+    private fileSystemRepo;
+    constructor(options: WorkspaceFactoryOptions);
+    load(rootPath: string): Promise<Workspace>;
+    private checkAuthFile;
+    create(rootPath: string, options?: {
+        name?: string;
+        modulesDir?: string;
+        projectsDir?: string;
+    }): Promise<Workspace>;
+    save(workspace: Workspace): Promise<void>;
+    findWorkspaceRoot(startPath: string): Promise<string | null>;
+    isWorkspace(workspacePath: string): Promise<boolean>;
+    loadOrFind(cwd?: string): Promise<Workspace>;
+    createProject(workspace: Workspace, name: string, options?: {
+        theme?: string;
+        language?: string;
+        contentDir?: string;
+        staticDir?: string;
+        publishDir?: string;
+    }): Promise<Project>;
+    deleteProject(workspace: Workspace, projectIdOrName: string, options?: {
+        deleteFiles?: boolean;
+    }): Promise<void>;
+    createProjectFromFolder(workspace: Workspace, name: string, sourceFolderPath: string, options?: {
+        theme?: string;
+        language?: string;
+    }): Promise<Project>;
+    createProjectFromFile(workspace: Workspace, name: string, sourceFilePath: string, options?: {
+        theme?: string;
+        language?: string;
+    }): Promise<Project>;
+    loadProject(projectPath: string): Promise<Project>;
+    saveProject(project: Project): Promise<void>;
+    findProjectRoot(startPath: string): Promise<string | null>;
+    createSnapshot(project: Project, snapshotName?: string): Promise<SnapshotMetadata>;
+    listSnapshots(project: Project): Promise<SnapshotMetadata[]>;
+    restoreSnapshot(project: Project, snapshotId: string, outputDir?: string): Promise<void>;
+    deleteSnapshot(project: Project, snapshotId: string): Promise<void>;
+    getSnapshot(project: Project, snapshotId: string): Promise<SnapshotMetadata>;
+    createIdentityStorage(workspace: Workspace): IdentityStorageProvider;
+    private createSampleContent;
+}

package/dist/internal/domain/workspace/index.d.ts

@@ -0,0 +1,9 @@
+export * from './type';
+export { WorkspaceMetadata } from './value-object/workspace-metadata';
+export { ProjectMetadata } from './value-object/project-metadata';
+export { FolderStructure } from './value-object/folder-structure';
+export * from './repository';
+export { Workspace } from './entity/workspace';
+export { Project, ProjectConfig } from './entity/project';
+export { Authentication } from './entity/authentication';
+export { WorkspaceFactory, WorkspaceFactoryOptions } from './factory/workspace-factory';

package/dist/internal/domain/workspace/repository/file-system.d.ts

@@ -0,0 +1,55 @@
+export interface FolderScanResult {
+    path: string;
+    name: string;
+    isDirectory: boolean;
+    isFile: boolean;
+}
+export interface ContentFolderInfo {
+    path: string;
+    languageCode: string;
+    weight: number;
+}
+export interface StaticFolderInfo {
+    path: string;
+}
+export interface FolderStructure {
+    rootPath: string;
+    contentFolders: ContentFolderInfo[];
+    staticFolder: StaticFolderInfo | null;
+    isStructured: boolean;
+}
+export interface SymlinkResult {
+    source: string;
+    target: string;
+    success: boolean;
+    error?: string;
+}
+export interface FileSystemRepository {
+    exists(path: string): Promise<boolean>;
+    isDirectory(path: string): Promise<boolean>;
+    isFile(path: string): Promise<boolean>;
+    readDirectory(path: string): Promise<FolderScanResult[]>;
+    scanFolderStructure(path: string): Promise<FolderStructure>;
+    createSymlink(source: string, target: string): Promise<SymlinkResult>;
+    createSymlinks(links: Array<{
+        source: string;
+        target: string;
+    }>): Promise<SymlinkResult[]>;
+    removeSymlink(path: string): Promise<void>;
+    isSymlink(path: string): Promise<boolean>;
+    readSymlink(path: string): Promise<string>;
+    createDirectory(path: string, recursive?: boolean): Promise<void>;
+    remove(path: string, recursive?: boolean): Promise<void>;
+    stat(path: string): Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        size: number;
+        mtime: Date;
+    }>;
+    copyFile(source: string, target: string): Promise<void>;
+    resolvePath(path: string): Promise<string>;
+    basename(path: string): string;
+    dirname(path: string): string;
+    join(...paths: string[]): string;
+}

package/dist/internal/domain/workspace/repository/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../repository';
+export * from './file-system';

package/dist/internal/domain/workspace/repository.d.ts

@@ -0,0 +1,52 @@
+import type { ProjectRegistry, SnapshotMetadata } from './type';
+export * from './repository/file-system';
+export type WorkspaceMetadataData = {
+    version: string;
+    id: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+    paths: {
+        modules: string;
+        projects: string;
+    };
+    defaults?: {
+        modulesDir?: string;
+        theme?: string;
+        language?: string;
+    };
+};
+export type ProjectMetadataData = {
+    id: string;
+    name: string;
+    workspaceId?: string;
+    createdAt: number;
+    updatedAt: number;
+    buildHistory?: any[];
+    previews?: any;
+};
+export interface WorkspaceRepository {
+    isWorkspace(path: string): Promise<boolean>;
+    initWorkspaceStructure(path: string, modulesDir: string, projectsDir: string): Promise<void>;
+    saveWorkspaceMetadata(path: string, metadata: WorkspaceMetadataData): Promise<void>;
+    loadWorkspaceMetadata(path: string): Promise<WorkspaceMetadataData>;
+    saveProjectRegistry(path: string, registry: ProjectRegistry): Promise<void>;
+    loadProjectRegistry(path: string): Promise<ProjectRegistry>;
+}
+export interface ProjectRepository {
+    isProject(path: string): Promise<boolean>;
+    initProjectStructure(path: string, contentDir: string, staticDir: string, publishDir: string): Promise<void>;
+    saveProjectMetadata(path: string, metadata: ProjectMetadataData): Promise<void>;
+    loadProjectMetadata(path: string): Promise<ProjectMetadataData>;
+    saveProjectConfig(path: string, config: any): Promise<void>;
+    createSampleContent(path: string, content: string): Promise<void>;
+    deleteProjectFiles(path: string): Promise<void>;
+    deleteProjectDirectory(path: string): Promise<void>;
+}
+export interface SnapshotRepository {
+    createSnapshot(projectPath: string, snapshotId: string, outputDir: string): Promise<SnapshotMetadata>;
+    listSnapshots(projectPath: string): Promise<SnapshotMetadata[]>;
+    getSnapshot(projectPath: string, snapshotId: string): Promise<SnapshotMetadata>;
+    restoreSnapshot(projectPath: string, snapshotId: string, outputDir: string): Promise<void>;
+    deleteSnapshot(projectPath: string, snapshotId: string): Promise<void>;
+}

package/dist/internal/domain/workspace/type.d.ts

@@ -0,0 +1,41 @@
+export interface ProjectEntry {
+    id: string;
+    name: string;
+    path: string;
+    absolutePath: string;
+    theme?: string;
+    createdAt: number;
+    updatedAt: number;
+    lastBuild?: number;
+    status: 'active' | 'archived';
+}
+export interface ProjectRegistry {
+    version: string;
+    projects: ProjectEntry[];
+}
+export interface BuildHistoryEntry {
+    timestamp: number;
+    type: 'build' | 'publish';
+    target?: string;
+    success: boolean;
+    previewId?: string;
+    duration?: number;
+    stats?: {
+        pages?: number;
+        size?: number;
+    };
+}
+export interface SnapshotMetadata {
+    id: string;
+    name: string;
+    timestamp: number;
+    outputDir: string;
+    storageDir: string;
+    size: number;
+    fileCount: number;
+}
+export interface PreviewsConfig {
+    autoSnapshot?: boolean;
+    retention?: number;
+    cleanupOlderThan?: number;
+}

package/dist/internal/domain/workspace/value-object/folder-structure.d.ts

@@ -0,0 +1,27 @@
+import type { FolderStructure as IFolderStructure, ContentFolderInfo, StaticFolderInfo } from '../repository/file-system';
+export declare class FolderStructure {
+    private readonly rootPath;
+    private readonly contentFolders;
+    private readonly staticFolder;
+    private readonly isStructured;
+    private constructor();
+    static fromScanResult(result: IFolderStructure): FolderStructure;
+    static createEmpty(rootPath: string): FolderStructure;
+    static createSingleContent(rootPath: string, contentPath: string, languageCode?: string): FolderStructure;
+    getRootPath(): string;
+    getContentFolders(): ContentFolderInfo[];
+    getStaticFolder(): StaticFolderInfo | null;
+    getIsStructured(): boolean;
+    hasContentFolders(): boolean;
+    hasStaticFolder(): boolean;
+    getContentFolderCount(): number;
+    getDefaultContentFolder(): ContentFolderInfo | null;
+    getLanguageContentFolders(): ContentFolderInfo[];
+    getContentFolderByLanguage(languageCode: string): ContentFolderInfo | null;
+    getSupportedLanguages(): string[];
+    isValid(): boolean;
+    isMultilingual(): boolean;
+    getSummary(): string;
+    toJSON(): IFolderStructure;
+    static fromJSON(json: IFolderStructure): FolderStructure;
+}