@mdfriday/foundry 26.2.13 → 26.3.2

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

@@ -0,0 +1,61 @@
+export declare class WorkspaceMetadata {
+    readonly version: string;
+    readonly id: string;
+    readonly name: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly paths: {
+        modules: string;
+        projects: string;
+    };
+    readonly defaults: {
+        modulesDir?: string;
+        theme?: string;
+        language?: string;
+    };
+    private constructor();
+    static create(data: {
+        version: string;
+        id: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+        paths: {
+            modules: string;
+            projects: string;
+        };
+        defaults?: {
+            modulesDir?: string;
+            theme?: string;
+            language?: string;
+        };
+    }): WorkspaceMetadata;
+    update(updates: Partial<{
+        name: string;
+        paths: {
+            modules: string;
+            projects: string;
+        };
+        defaults: {
+            modulesDir?: string;
+            theme?: string;
+            language?: string;
+        };
+    }>): WorkspaceMetadata;
+    toJSON(): {
+        version: string;
+        id: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+        paths: {
+            modules: string;
+            projects: string;
+        };
+        defaults?: {
+            modulesDir?: string;
+            theme?: string;
+            language?: string;
+        };
+    };
+}

package/dist/internal/infrastructure/http/netlify-http-client.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient, HttpResponse } from '@internal/domain/publish/repository/http-client';
+export declare class NetlifyHttpClient implements HttpClient {
+    postJSON(url: string, data: any, headers?: Record<string, string>): Promise<HttpResponse>;
+    postMultipart(url: string, formData: Record<string, any>, headers?: Record<string, string>): Promise<HttpResponse>;
+    putBinary(url: string, data: Buffer | Uint8Array, headers?: Record<string, string>): Promise<HttpResponse>;
+    get(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
+    private createResponse;
+}

package/dist/internal/infrastructure/http/node-http-client.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient, HttpResponse } from '@internal/domain/identity/repository';
+export declare class NodeHttpClient implements HttpClient {
+    post(url: string, data: any, headers?: Record<string, string>): Promise<HttpResponse>;
+    postForm(url: string, data: Record<string, string>): Promise<HttpResponse>;
+    postMultipart(url: string, data: Record<string, any>, headers?: Record<string, string>): Promise<HttpResponse>;
+    get(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
+}

package/dist/internal/infrastructure/index.d.ts

@@ -0,0 +1,6 @@
+export { NodeWorkspaceRepository, NodeProjectRepository, } from './persistence/node-workspace-repository';
+export { NodeSnapshotRepository } from './persistence/node-snapshot-repository';
+export { NodeFileSystemRepository } from './persistence/node-file-system';
+export { NodeManifestRepository } from './persistence/node-manifest-repository';
+export { NodeHttpClient } from './http/node-http-client';
+export { NetlifyHttpClient } from './http/netlify-http-client';

package/dist/internal/infrastructure/persistence/node-file-system.d.ts

@@ -0,0 +1,30 @@
+import { FileSystemRepository, FolderScanResult, FolderStructure, SymlinkResult } from '@internal/domain/workspace/repository/file-system';
+export declare class NodeFileSystemRepository implements FileSystemRepository {
+    exists(filePath: string): Promise<boolean>;
+    isDirectory(filePath: string): Promise<boolean>;
+    isFile(filePath: string): Promise<boolean>;
+    readDirectory(dirPath: string): Promise<FolderScanResult[]>;
+    scanFolderStructure(dirPath: string): Promise<FolderStructure>;
+    createSymlink(source: string, target: string): Promise<SymlinkResult>;
+    createSymlinks(links: Array<{
+        source: string;
+        target: string;
+    }>): Promise<SymlinkResult[]>;
+    removeSymlink(filePath: string): Promise<void>;
+    isSymlink(filePath: string): Promise<boolean>;
+    readSymlink(filePath: string): Promise<string>;
+    createDirectory(dirPath: string, recursive?: boolean): Promise<void>;
+    remove(filePath: string, recursive?: boolean): Promise<void>;
+    stat(filePath: string): Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        size: number;
+        mtime: Date;
+    }>;
+    copyFile(source: string, target: string): Promise<void>;
+    resolvePath(filePath: string): Promise<string>;
+    basename(filePath: string): string;
+    dirname(filePath: string): string;
+    join(...paths: string[]): string;
+}

package/dist/internal/infrastructure/persistence/node-manifest-repository.d.ts

@@ -0,0 +1,11 @@
+import { ManifestRepository } from '@internal/domain/publish';
+import { PublishManifest } from '@internal/domain/publish';
+export declare class NodeManifestRepository implements ManifestRepository {
+    loadManifest(projectPath: string, publishMethod: 'ftp' | 'netlify' | 'mdfriday'): Promise<PublishManifest | null>;
+    saveManifest(projectPath: string, manifest: PublishManifest): Promise<void>;
+    generateManifest(projectId: string, publicDir: string, publishMethod: 'ftp' | 'netlify' | 'mdfriday', remoteConfig?: any): Promise<PublishManifest>;
+    deleteManifest(projectPath: string, publishMethod: 'ftp' | 'netlify' | 'mdfriday'): Promise<boolean>;
+    private getManifestPath;
+    private scanDirectory;
+    private calculateFileHash;
+}

package/dist/internal/infrastructure/persistence/node-snapshot-repository.d.ts

@@ -0,0 +1,12 @@
+import { SnapshotRepository } from '@internal/domain/workspace/repository';
+import { SnapshotMetadata } from '@internal/domain/workspace/type';
+export declare class NodeSnapshotRepository implements 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>;
+    private copyDirectory;
+    private getDirectorySize;
+    private countFiles;
+}

package/dist/internal/infrastructure/persistence/node-workspace-repository.d.ts

@@ -0,0 +1,20 @@
+import { WorkspaceRepository, ProjectRepository, WorkspaceMetadataData, ProjectMetadataData } from '@internal/domain/workspace/repository';
+import { ProjectRegistry } from '@internal/domain/workspace/type';
+export declare class NodeWorkspaceRepository implements WorkspaceRepository {
+    isWorkspace(workspacePath: string): Promise<boolean>;
+    initWorkspaceStructure(workspacePath: string, modulesDir: string, projectsDir: string): Promise<void>;
+    saveWorkspaceMetadata(workspacePath: string, metadata: WorkspaceMetadataData): Promise<void>;
+    loadWorkspaceMetadata(workspacePath: string): Promise<WorkspaceMetadataData>;
+    saveProjectRegistry(workspacePath: string, registry: ProjectRegistry): Promise<void>;
+    loadProjectRegistry(workspacePath: string): Promise<ProjectRegistry>;
+}
+export declare class NodeProjectRepository implements ProjectRepository {
+    isProject(projectPath: string): Promise<boolean>;
+    initProjectStructure(projectPath: string, contentDir: string, staticDir: string, publishDir: string): Promise<void>;
+    saveProjectMetadata(projectPath: string, metadata: ProjectMetadataData): Promise<void>;
+    loadProjectMetadata(projectPath: string): Promise<ProjectMetadataData>;
+    saveProjectConfig(projectPath: string, config: any): Promise<void>;
+    createSampleContent(contentPath: string, content: string): Promise<void>;
+    deleteProjectFiles(projectPath: string): Promise<void>;
+    deleteProjectDirectory(projectPath: string): Promise<void>;
+}

package/dist/internal/interfaces/cli/commands/auth.d.ts

@@ -0,0 +1,121 @@
+import { Command, CommandResult } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class AuthLoginCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class AuthRegisterCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class AuthLogoutCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class AuthStatusCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class AuthConfigCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseTrialCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseLoginCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseActivateCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseInfoCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseUsageCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class LicenseResetCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class DomainInfoCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class SubdomainCheckCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class SubdomainUpdateCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class CustomDomainCheckCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class CustomDomainAddCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class DomainHttpsCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}

package/dist/internal/interfaces/cli/commands/build.d.ts

@@ -0,0 +1,10 @@
+import { Command, CommandResult, BuildOptions } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class BuildCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: BuildOptions): Promise<CommandResult>;
+    private cleanOutputDir;
+}

package/dist/internal/interfaces/cli/commands/config.d.ts

@@ -0,0 +1,42 @@
+import { Command, CommandResult } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class ConfigGetCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+    private formatValue;
+}
+export declare class ConfigSetCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+    private parseValue;
+    private formatValue;
+}
+export declare class ConfigListCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+    private formatConfig;
+    private formatObject;
+}
+export declare class ConfigUnsetCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class ConfigEditCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+}

package/dist/internal/interfaces/cli/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from './workspace';
+export * from './project';
+export * from './build';
+export * from './serve';
+export * from './snapshot';
+export * from './auth';

package/dist/internal/interfaces/cli/commands/project.d.ts

@@ -0,0 +1,36 @@
+import { Command, CommandResult, ProjectCreateOptions } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class ProjectNewCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: ProjectCreateOptions): Promise<CommandResult>;
+}
+export declare class ProjectListCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: {
+        format?: 'table' | 'json';
+        status?: 'active' | 'archived';
+    }): Promise<CommandResult>;
+}
+export declare class ProjectShowCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}
+export declare class ProjectDeleteCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: {
+        force?: boolean;
+        keepFiles?: boolean;
+    }): Promise<CommandResult>;
+}

package/dist/internal/interfaces/cli/commands/publish.d.ts

@@ -0,0 +1,27 @@
+import { Command, CommandResult } from '../types';
+import { PublishAppService } from '@internal/application/publish';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export interface PublishOptions {
+    project?: string;
+    force?: boolean;
+    verbose?: boolean;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    remotePath?: string;
+    secure?: boolean;
+    siteId?: string;
+    token?: string;
+    type?: 'share' | 'sub' | 'custom' | 'enterprise';
+    licenseKey?: string;
+}
+export declare class PublishCommand implements Command {
+    private publishService;
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(publishService: PublishAppService, workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: PublishOptions): Promise<CommandResult>;
+    private parseConfigOverride;
+}

package/dist/internal/interfaces/cli/commands/serve.d.ts

@@ -0,0 +1,16 @@
+import { Command, CommandResult, ServeOptions } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { PublishAppService } from '@internal/application/publish';
+export declare class ServeCommand implements Command {
+    private workspaceAppService;
+    private publishAppService?;
+    name: string;
+    description: string;
+    private coordinator?;
+    private publishTimer?;
+    constructor(workspaceAppService: WorkspaceAppService, publishAppService?: PublishAppService | undefined);
+    execute(_args: string[], options: ServeOptions): Promise<CommandResult>;
+    private openBrowser;
+    cleanup(): Promise<void>;
+    private autoPublish;
+}

package/dist/internal/interfaces/cli/commands/snapshot.d.ts

@@ -0,0 +1,25 @@
+import { Command, CommandResult } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class SnapshotListCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], options: Record<string, any>): Promise<CommandResult>;
+    private formatBytes;
+}
+export declare class SnapshotRestoreCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+    private formatBytes;
+}
+export declare class SnapshotDeleteCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+}

package/dist/internal/interfaces/cli/commands/workspace.d.ts

@@ -0,0 +1,16 @@
+import { Command, CommandResult, WorkspaceInitOptions } from '../types';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare class WorkspaceInitCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(args: string[], options: WorkspaceInitOptions): Promise<CommandResult>;
+}
+export declare class WorkspaceInfoCommand implements Command {
+    private workspaceAppService;
+    name: string;
+    description: string;
+    constructor(workspaceAppService: WorkspaceAppService);
+    execute(_args: string[], _options: Record<string, any>): Promise<CommandResult>;
+}

package/dist/internal/interfaces/cli/container.d.ts

@@ -0,0 +1,7 @@
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { IdentityAppService } from '@internal/application/identity';
+export declare function createWorkspaceFactory(): WorkspaceFactory;
+export declare function createWorkspaceAppService(): WorkspaceAppService;
+export declare function createIdentityService(projectPath?: string): Promise<IdentityAppService>;
+export declare function createPublishAppService(): any;

package/dist/internal/interfaces/cli/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { CLIRouter } from './router';
+declare function main(): Promise<void>;
+export { CLIRouter, main };

package/dist/internal/interfaces/cli/router.d.ts

@@ -0,0 +1,27 @@
+import { Command, CommandResult } from './types';
+export declare class CommandRegistry {
+    private commands;
+    private initialized;
+    constructor();
+    waitForInitialization(): Promise<void>;
+    private registerCommands;
+    private register;
+    get(name: string): Command | undefined;
+    getAll(): Command[];
+    has(name: string): boolean;
+}
+export declare class CLIRouter {
+    private registry;
+    constructor();
+    parseArgs(argv: string[]): {
+        command: string;
+        subcommand?: string;
+        args: string[];
+        options: Record<string, any>;
+    };
+    private isSubcommand;
+    private camelCase;
+    route(argv: string[]): Promise<CommandResult>;
+    private showHelp;
+    private showVersion;
+}

package/dist/internal/interfaces/cli/types.d.ts

@@ -0,0 +1,52 @@
+export interface CommandResult {
+    success: boolean;
+    message?: string;
+    error?: Error;
+    data?: any;
+}
+export interface Command {
+    name: string;
+    description: string;
+    execute(args: string[], options: Record<string, any>): Promise<CommandResult>;
+}
+export interface CommandOptions {
+    [key: string]: any;
+}
+export interface WorkspaceInitOptions {
+    name?: string;
+    modulesDir?: string;
+    projectsDir?: string;
+}
+export interface ProjectCreateOptions {
+    theme?: string;
+    language?: string;
+    path?: string;
+    source?: string;
+    sourceFile?: string;
+    noSample?: boolean;
+    interactive?: boolean;
+}
+export interface BuildOptions {
+    project?: string;
+    source?: string;
+    destination?: string;
+    modulesDir?: string;
+    contentDirs?: string[];
+    parallel?: boolean;
+    watch?: boolean;
+    clean?: boolean;
+    snapshot?: boolean;
+    snapshotName?: string;
+}
+export interface ServeOptions {
+    project?: string;
+    port?: number;
+    host?: string;
+    open?: boolean;
+    livereload?: boolean;
+    livereloadPort?: number;
+    publish?: 'ftp' | 'netlify' | 'mdfriday';
+    publishDelay?: number;
+    type?: 'share' | 'sub' | 'custom' | 'enterprise';
+    licenseKey?: string;
+}

package/dist/internal/interfaces/obsidian/container.d.ts

@@ -0,0 +1,4 @@
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { WorkspaceAppService } from '@internal/application/workspace';
+export declare function createWorkspaceFactory(): WorkspaceFactory;
+export declare function createWorkspaceAppService(): WorkspaceAppService;

package/dist/internal/interfaces/obsidian/index.d.ts

@@ -0,0 +1,2 @@
+export { ObsidianWorkspaceService, createObsidianWorkspaceService, ObsidianWorkspaceInitOptions, ObsidianWorkspaceInfo, ObsidianWorkspaceResult, } from './workspace';
+export { createWorkspaceAppService, createWorkspaceFactory, } from './container';

package/dist/internal/interfaces/obsidian/workspace.d.ts

@@ -0,0 +1,38 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { WorkspaceFactory } from '@internal/domain/workspace';
+export interface ObsidianWorkspaceInitOptions {
+    name?: string;
+    modulesDir?: string;
+    projectsDir?: string;
+}
+export interface ObsidianWorkspaceInfo {
+    id: string;
+    name: string;
+    path: string;
+    createdAt: string;
+    modulesDir: string;
+    projectsDir: string;
+    projectCount: number;
+    projects: Array<{
+        id: string;
+        name: string;
+        path: string;
+        createdAt: string;
+        lastBuild?: string;
+    }>;
+}
+export interface ObsidianWorkspaceResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+export declare class ObsidianWorkspaceService {
+    private workspaceAppService;
+    private workspaceFactory;
+    constructor(workspaceAppService: WorkspaceAppService, workspaceFactory: WorkspaceFactory);
+    initWorkspace(workspacePath: string, options?: ObsidianWorkspaceInitOptions): Promise<ObsidianWorkspaceResult<ObsidianWorkspaceInfo>>;
+    getWorkspaceInfo(workspacePath: string): Promise<ObsidianWorkspaceResult<ObsidianWorkspaceInfo>>;
+    workspaceExists(workspacePath: string): Promise<ObsidianWorkspaceResult<boolean>>;
+}
+export declare function createObsidianWorkspaceService(): ObsidianWorkspaceService;

package/dist/pkg/progress-bar.d.ts

@@ -0,0 +1,20 @@
+export interface ProgressBarOptions {
+    width?: number;
+    showPercentage?: boolean;
+    showMessage?: boolean;
+    clearOnComplete?: boolean;
+}
+export declare class ProgressBar {
+    private width;
+    private showPercentage;
+    private showMessage;
+    private clearOnComplete;
+    private lastOutput;
+    constructor(options?: ProgressBarOptions);
+    update(percentage: number, message?: string): void;
+    complete(message?: string): void;
+    clear(): void;
+    static create(percentage: number, width?: number): string;
+}
+export declare function formatBytes(bytes: number): string;
+export declare function formatDuration(ms: number): string;