@mdfriday/foundry 26.4.12 → 26.4.13

package/dist/internal/interfaces/obsidian/adapters/identity-adapter.d.ts

@@ -0,0 +1,5 @@
+import { HttpClient } from '@internal/domain/identity';
+import { IdentityAppService } from '@internal/application/identity';
+export interface IdentityAdapter {
+    getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;
+}

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

@@ -0,0 +1,2 @@
+export type { IdentityAdapter } from './identity-adapter';
+export type { WorkspaceAdapter } from './workspace-adapter';

package/dist/internal/interfaces/obsidian/adapters/workspace-adapter.d.ts

@@ -0,0 +1,8 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { FileSystemRepository } from '@internal/domain/workspace/repository';
+export interface WorkspaceAdapter {
+    getWorkspaceAppService(): WorkspaceAppService;
+    getWorkspaceFactory(): WorkspaceFactory;
+    getFileSystemRepository(): FileSystemRepository;
+}

package/dist/internal/interfaces/obsidian/desktop/adapters/identity-adapter.d.ts

@@ -0,0 +1,6 @@
+import { HttpClient } from '@internal/domain/identity';
+import { IdentityAppService } from '@internal/application/identity';
+import type { IdentityAdapter } from '../../adapters';
+export declare class DesktopIdentityAdapter implements IdentityAdapter {
+    getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;
+}

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

@@ -0,0 +1,2 @@
+export { DesktopIdentityAdapter } from './identity-adapter';
+export { DesktopWorkspaceAdapter } from './workspace-adapter';

package/dist/internal/interfaces/obsidian/desktop/adapters/workspace-adapter.d.ts

@@ -0,0 +1,12 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { FileSystemRepository } from '@internal/domain/workspace/repository';
+import type { WorkspaceAdapter } from '../../adapters';
+export declare class DesktopWorkspaceAdapter implements WorkspaceAdapter {
+    private workspaceAppService?;
+    private workspaceFactory?;
+    private fileSystemRepo?;
+    getWorkspaceAppService(): WorkspaceAppService;
+    getWorkspaceFactory(): WorkspaceFactory;
+    getFileSystemRepository(): FileSystemRepository;
+}

package/dist/internal/interfaces/obsidian/{container.d.ts → desktop/container.d.ts}

@@ -1,8 +1,7 @@
-import type { ObsidianEnvironmentConfig } from './config-types';
 import { HttpClient } from '@internal/domain/identity';
 import { IdentityAppService } from '@internal/application';
 import { WorkspaceAppService } from '@internal/application/workspace';
 export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createPublishAppService, } from '@internal/application/container';
-export declare function createObsidianWorkspaceAppService(config?: ObsidianEnvironmentConfig): WorkspaceAppService;
-export declare function createObsidianIdentityService(workspacePath: string, httpClient: HttpClient, config?: ObsidianEnvironmentConfig): Promise<IdentityAppService>;
+export declare function createObsidianWorkspaceAppService(): WorkspaceAppService;
+export declare function createObsidianIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;
 export declare function getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;

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

@@ -0,0 +1,22 @@
+import { HttpClient } from '@internal/domain/identity';
+import { HttpClient as PublishHttpClient } from '@internal/domain/publish/repository/http-client';
+import { ObsidianAuthService } from '../services/auth.service';
+import { ObsidianLicenseService } from '../services/license.service';
+import { ObsidianWorkspaceService } from '../services/workspace.service';
+import { ObsidianGlobalConfigService, ObsidianProjectConfigService } from '../services/config.service';
+import { ObsidianProjectService } from '../services/project.service';
+import { ObsidianBuildService } from '../services/build.service';
+import { ObsidianServeService } from '../services/serve.service';
+import { ObsidianPublishService } from '../services/publish.service';
+import { ObsidianDomainService } from '../services/domain.service';
+export declare function createObsidianWorkspaceService(): ObsidianWorkspaceService;
+export declare function createObsidianAuthService(httpClient: HttpClient): ObsidianAuthService;
+export declare function createObsidianLicenseService(httpClient: HttpClient): ObsidianLicenseService;
+export declare function createObsidianGlobalConfigService(): ObsidianGlobalConfigService;
+export declare function createObsidianProjectConfigService(): ObsidianProjectConfigService;
+export declare function createObsidianProjectService(): ObsidianProjectService;
+export declare function createObsidianBuildService(): ObsidianBuildService;
+export declare function createObsidianServeService(httpClient?: PublishHttpClient): ObsidianServeService;
+export declare function createObsidianPublishService(httpClient: PublishHttpClient): ObsidianPublishService;
+export declare function createObsidianDomainService(httpClient: HttpClient): ObsidianDomainService;
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createPublishAppService, createObsidianWorkspaceAppService, createObsidianIdentityService, getIdentityService, } from './container';

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

@@ -1,18 +1,8 @@
+export * from './types';
 export type { ObsidianEnvironmentConfig, ObsidianFullPersistenceConfig, ObsidianBasicPersistenceConfig, } from './config-types';
 export { isFullPersistenceConfig } from './config-types';
 export type { WorkspaceRepository, ProjectRepository, SnapshotRepository, FileSystemRepository, WorkspaceMetadataData, ProjectMetadataData, FolderStructure, FolderScanResult, ContentFolderInfo, StaticFolderInfo, SymlinkResult, } from '@internal/domain/workspace/repository';
-export type { ProjectRegistry, ProjectEntry, BuildHistoryEntry, } from '@internal/domain/workspace/type';
-export type { SnapshotMetadata } from '@internal/domain/workspace/type';
-export { ObsidianWorkspaceService, createObsidianWorkspaceService, ObsidianWorkspaceInitOptions, ObsidianWorkspaceInfo, ObsidianWorkspaceResult, } from './workspace';
-export { ObsidianProjectService, createObsidianProjectService, ObsidianProjectCreateOptions, ObsidianProjectInfo, ObsidianProjectResult, } from './project';
-export { ObsidianBuildService, createObsidianBuildService, ObsidianBuildOptions, ObsidianBuildResult, } from './build';
-export { ObsidianGlobalConfigService, ObsidianProjectConfigService, createObsidianGlobalConfigService, createObsidianProjectConfigService, ObsidianConfigResult, ConfigGetResult, ConfigListResult, } from './config';
-export { ObsidianPublishService, createObsidianPublishService, ObsidianPublishMethod, ObsidianPublishOptions, ObsidianPublishProgress, ObsidianPublishResult, ObsidianTestConnectionResult, } from './publish';
-export { ObsidianServeService, createObsidianServeService, ObsidianServeOptions, ObsidianServeResult, ObsidianServeProgress, } from './serve';
-export { ObsidianLicenseService, createObsidianLicenseService, ObsidianLicenseInfo, ObsidianLicenseUsage, ObsidianLicenseResult, } from './license';
-export { ObsidianAuthService, createObsidianAuthService, ObsidianAuthStatus, ObsidianSyncConfig, ObsidianServerConfig, ObsidianAuthResult, } from './auth';
-export { ObsidianDomainService, createObsidianDomainService, ObsidianDomainInfo, ObsidianSubdomainCheckResult, ObsidianSubdomainUpdateResult, ObsidianCustomDomainCheckResult, ObsidianCustomDomainAddResult, ObsidianHttpsCertificate, ObsidianHttpsStatusResult, ObsidianDomainResult, } from './domain';
-export { createObsidianWorkspaceAppService, createObsidianIdentityService, createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createPublishAppService, } from './container';
+export type { ProjectRegistry, ProjectEntry, BuildHistoryEntry, SnapshotMetadata, } from '@internal/domain/workspace/type';
 export type { HttpClient as PublishHttpClient, HttpResponse as PublishHttpResponse } from '@internal/domain/publish/repository/http-client';
 export type { HttpClient as IdentityHttpClient, HttpResponse as IdentityHttpResponse } from '@internal/domain/identity';
 export type { AnyPublishConfig, FTPConfig, NetlifyConfig, MDFridayConfig, } from '@internal/domain/publish';

package/dist/internal/interfaces/obsidian/mobile/adapters/identity-adapter.d.ts

@@ -0,0 +1,9 @@
+import { HttpClient } from '@internal/domain/identity';
+import { IdentityAppService } from '@internal/application/identity';
+import type { IdentityAdapter } from '../../adapters';
+import type { ObsidianMobileEnvironmentConfig } from '../config-types';
+export declare class MobileIdentityAdapter implements IdentityAdapter {
+    private readonly config;
+    constructor(config: ObsidianMobileEnvironmentConfig);
+    getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;
+}

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

@@ -0,0 +1,2 @@
+export { MobileIdentityAdapter } from './identity-adapter';
+export { MobileWorkspaceAdapter } from './workspace-adapter';

package/dist/internal/interfaces/obsidian/mobile/adapters/workspace-adapter.d.ts

@@ -0,0 +1,13 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { FileSystemRepository } from '@internal/domain/workspace/repository';
+import type { WorkspaceAdapter } from '../../adapters';
+import type { ObsidianMobileEnvironmentConfig } from '../config-types';
+export declare class MobileWorkspaceAdapter implements WorkspaceAdapter {
+    private readonly config;
+    private workspaceAppService?;
+    constructor(config: ObsidianMobileEnvironmentConfig);
+    getWorkspaceAppService(): WorkspaceAppService;
+    getWorkspaceFactory(): WorkspaceFactory;
+    getFileSystemRepository(): FileSystemRepository;
+}

package/dist/internal/interfaces/obsidian/{mobile-container.d.ts → mobile/container.d.ts}

@@ -1,4 +1,4 @@
-import type { ObsidianMobileEnvironmentConfig } from './mobile-config-types';
+import type { ObsidianMobileEnvironmentConfig } from './config-types';
 import { HttpClient } from '@internal/domain/identity';
 import { IdentityAppService } from '@internal/application/identity';
 import { WorkspaceAppService } from '@internal/application/workspace';

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

@@ -0,0 +1,16 @@
+import { HttpClient } from '@internal/domain/identity';
+import { ObsidianAuthService } from '../services/auth.service';
+import { ObsidianLicenseService } from '../services/license.service';
+import { ObsidianWorkspaceService } from '../services/workspace.service';
+import { ObsidianGlobalConfigService } from '../services/config.service';
+import type { ObsidianMobileEnvironmentConfig } from './config-types';
+export type { ObsidianMobileEnvironmentConfig, ObsidianMobilePersistenceConfig, ObsidianEnvironmentConfig, ObsidianBasicPersistenceConfig, } from './config-types';
+export declare function createObsidianWorkspaceService(config: ObsidianMobileEnvironmentConfig): ObsidianWorkspaceService;
+export declare function createObsidianAuthService(httpClient: HttpClient, config: ObsidianMobileEnvironmentConfig): ObsidianAuthService;
+export declare function createObsidianLicenseService(httpClient: HttpClient, config: ObsidianMobileEnvironmentConfig): ObsidianLicenseService;
+export declare function createObsidianGlobalConfigService(config: ObsidianMobileEnvironmentConfig): ObsidianGlobalConfigService;
+export { createObsidianWorkspaceAppService, createObsidianIdentityService, } from './container';
+export type { WorkspaceRepository, FileSystemRepository, WorkspaceMetadataData, FolderStructure, FolderScanResult, ContentFolderInfo, StaticFolderInfo, SymlinkResult, } from '@internal/domain/workspace/repository';
+export type { ProjectRegistry, ProjectEntry, } from '@internal/domain/workspace/type';
+export type { HttpClient as IdentityHttpClient, HttpResponse as IdentityHttpResponse } from '@internal/domain/identity';
+export type { SyncConfig, SyncConfigData, } from '@internal/domain/identity';

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

@@ -1,10 +1,2 @@
-export type { ObsidianMobileEnvironmentConfig, ObsidianMobilePersistenceConfig, ObsidianEnvironmentConfig, ObsidianBasicPersistenceConfig, } from './mobile-config-types';
-export type { WorkspaceRepository, FileSystemRepository, WorkspaceMetadataData, FolderStructure, FolderScanResult, ContentFolderInfo, StaticFolderInfo, SymlinkResult, } from '@internal/domain/workspace/repository';
-export type { ProjectRegistry, ProjectEntry, } from '@internal/domain/workspace/type';
-export type { HttpClient as IdentityHttpClient, HttpResponse as IdentityHttpResponse } from '@internal/domain/identity';
-export { ObsidianWorkspaceService, createObsidianWorkspaceService, type ObsidianWorkspaceInitOptions, type ObsidianWorkspaceInfo, type ObsidianWorkspaceResult, } from './workspace';
-export { ObsidianAuthService, createObsidianAuthService, type ObsidianAuthStatus, type ObsidianSyncConfig, type ObsidianServerConfig, type ObsidianAuthResult, } from './auth';
-export { ObsidianLicenseService, createObsidianLicenseService, type ObsidianLicenseInfo, type ObsidianLicenseUsage, type ObsidianLicenseResult, } from './license';
-export { ObsidianGlobalConfigService, createObsidianGlobalConfigService, type ObsidianConfigResult, type ConfigGetResult, type ConfigListResult, } from './config';
-export { createObsidianWorkspaceAppService, createObsidianIdentityService, } from './mobile-container';
-export type { SyncConfig, SyncConfigData, } from '@internal/domain/identity';
+export * from './mobile/index';
+export * from './types';

package/dist/internal/interfaces/obsidian/services/auth.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '@internal/domain/identity';
+import type { IdentityAdapter } from '../adapters';
+import type { ObsidianAuthStatus, ObsidianServerConfig, ObsidianAuthResult } from '../types';
+export declare class ObsidianAuthService {
+    private readonly httpClient;
+    private readonly identityAdapter;
+    constructor(httpClient: HttpClient, identityAdapter: IdentityAdapter);
+    getStatus(workspacePath: string): Promise<ObsidianAuthResult<ObsidianAuthStatus>>;
+    getConfig(workspacePath: string): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
+    updateConfig(workspacePath: string, config: ObsidianServerConfig): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
+}

package/dist/internal/interfaces/obsidian/services/build.service.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianBuildOptions, ObsidianBuildResult } from '../types/build';
+export declare class ObsidianBuildService {
+    private readonly workspaceAdapter;
+    constructor(workspaceAdapter: WorkspaceAdapter);
+    buildProject(options: ObsidianBuildOptions): Promise<ObsidianBuildResult>;
+    private cleanOutputDir;
+}

package/dist/internal/interfaces/obsidian/{config.d.ts → services/config.service.d.ts}

@@ -1,24 +1,8 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
-import type { ObsidianMobileEnvironmentConfig } from './mobile-config-types';
-export interface ObsidianConfigResult<T = any> {
-    success: boolean;
-    message?: string;
-    data?: T;
-    error?: string;
-}
-export interface ConfigGetResult {
-    key: string;
-    value: any;
-    project?: string;
-}
-export interface ConfigListResult {
-    config: Record<string, any>;
-    scope: 'global' | 'project';
-    project?: string;
-}
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianConfigResult, ConfigGetResult, ConfigListResult } from '../types';
 export declare class ObsidianGlobalConfigService {
-    private workspaceAppService;
-    constructor(workspaceAppService: WorkspaceAppService);
+    private readonly workspaceAdapter;
+    constructor(workspaceAdapter: WorkspaceAdapter);
     get(workspacePath: string, key: string): Promise<ObsidianConfigResult<ConfigGetResult>>;
     set(workspacePath: string, key: string, value: any): Promise<ObsidianConfigResult<ConfigGetResult>>;
     list(workspacePath: string): Promise<ObsidianConfigResult<ConfigListResult>>;
@@ -30,8 +14,8 @@ export declare class ObsidianGlobalConfigService {
     }>>;
 }
 export declare class ObsidianProjectConfigService {
-    private workspaceAppService;
-    constructor(workspaceAppService: WorkspaceAppService);
+    private readonly workspaceAdapter;
+    constructor(workspaceAdapter: WorkspaceAdapter);
     get(workspacePath: string, projectName: string, key: string): Promise<ObsidianConfigResult<ConfigGetResult>>;
     set(workspacePath: string, projectName: string, key: string, value: any): Promise<ObsidianConfigResult<ConfigGetResult>>;
     setAll(workspacePath: string, projectName: string, config: Record<string, any>): Promise<ObsidianConfigResult<ConfigListResult>>;
@@ -45,5 +29,3 @@ export declare class ObsidianProjectConfigService {
         project: string;
     }>>;
 }
-export declare function createObsidianGlobalConfigService(config?: ObsidianMobileEnvironmentConfig): ObsidianGlobalConfigService;
-export declare function createObsidianProjectConfigService(config?: ObsidianMobileEnvironmentConfig): ObsidianProjectConfigService;

package/dist/internal/interfaces/obsidian/services/domain.service.d.ts

@@ -0,0 +1,15 @@
+import type { IdentityAdapter } from '../adapters';
+import type { ObsidianDomainInfo, ObsidianSubdomainCheckResult, ObsidianSubdomainUpdateResult, ObsidianCustomDomainCheckResult, ObsidianCustomDomainAddResult, ObsidianHttpsStatusResult, ObsidianDomainResult } from '../types/domain';
+import { HttpClient } from '@internal/domain/identity';
+export declare class ObsidianDomainService {
+    private readonly httpClient;
+    private readonly identityAdapter;
+    constructor(httpClient: HttpClient, identityAdapter: IdentityAdapter);
+    private getIdentityService;
+    getDomainInfo(workspacePath: string): Promise<ObsidianDomainResult<ObsidianDomainInfo>>;
+    checkSubdomain(workspacePath: string, subdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainCheckResult>>;
+    updateSubdomain(workspacePath: string, newSubdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainUpdateResult>>;
+    checkCustomDomain(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainCheckResult>>;
+    addCustomDomain(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainAddResult>>;
+    checkHttpsStatus(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianHttpsStatusResult>>;
+}

package/dist/internal/interfaces/obsidian/services/license.service.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from '@internal/domain/identity';
+import type { IdentityAdapter } from '../adapters';
+import type { ObsidianLicenseInfo, ObsidianLicenseUsage, ObsidianLicenseResult } from '../types';
+export declare class ObsidianLicenseService {
+    private readonly httpClient;
+    private readonly identityAdapter;
+    constructor(httpClient: HttpClient, identityAdapter: IdentityAdapter);
+    requestTrial(workspacePath: string, email: string): Promise<ObsidianLicenseResult<{
+        email: string;
+        licenseKey: string;
+        password: string;
+        validityDays: number;
+    }>>;
+    requestAndActivateTrial(workspacePath: string, email: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    loginWithLicense(workspacePath: string, licenseKey: string): Promise<ObsidianLicenseResult<{}>>;
+    activateLicense(workspacePath: string, licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    getLicenseInfo(workspacePath: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    getLicenseUsage(workspacePath: string): Promise<ObsidianLicenseResult<ObsidianLicenseUsage>>;
+    resetUsage(workspacePath: string, force: boolean): Promise<ObsidianLicenseResult<any>>;
+    hasActiveLicense(workspacePath: string): Promise<boolean>;
+    private buildLicenseInfo;
+}

package/dist/internal/interfaces/obsidian/services/project.service.d.ts

@@ -0,0 +1,17 @@
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianProjectCreateOptions, ObsidianProjectInfo, ObsidianProjectResult, ObsidianFolderStructureInfo } from '../types/project';
+export declare class ObsidianProjectService {
+    private readonly workspaceAdapter;
+    constructor(workspaceAdapter: WorkspaceAdapter);
+    createProject(options: ObsidianProjectCreateOptions): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
+    private createProjectFromFile;
+    private createProjectFromFolder;
+    private createEmptyProject;
+    private buildProjectInfo;
+    listProjects(workspacePath: string): Promise<ObsidianProjectResult<ObsidianProjectInfo[]>>;
+    getProjectInfo(workspacePath: string, projectName: string): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
+    deleteProject(workspacePath: string, projectIdOrName: string, options?: {
+        deleteFiles?: boolean;
+    }): Promise<ObsidianProjectResult<void>>;
+    scanFolderStructure(folderPath: string): Promise<ObsidianProjectResult<ObsidianFolderStructureInfo>>;
+}

package/dist/internal/interfaces/obsidian/services/publish.service.d.ts

@@ -0,0 +1,11 @@
+import { PublishAppService } from '@internal/application/publish';
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianPublishOptions, ObsidianPublishResult, ObsidianPublishProgress, ObsidianTestConnectionResult } from '../types/publish';
+import { AnyPublishConfig } from '@internal/domain/publish';
+export declare class ObsidianPublishService {
+    private readonly workspaceAdapter;
+    private publishAppService;
+    constructor(publishAppService: PublishAppService, workspaceAdapter: WorkspaceAdapter);
+    publish(options: ObsidianPublishOptions, onProgress?: (progress: ObsidianPublishProgress) => void): Promise<ObsidianPublishResult>;
+    testConnection(workspacePath: string, projectName: string, config: AnyPublishConfig): Promise<ObsidianTestConnectionResult>;
+}

package/dist/internal/interfaces/obsidian/services/serve.service.d.ts

@@ -0,0 +1,17 @@
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianServeOptions, ObsidianServeResult, ObsidianServeProgress } from '../types/serve';
+import { PublishAppService } from '@internal/application/publish';
+export declare class ObsidianServeService {
+    private readonly workspaceAdapter;
+    private publishAppService;
+    private coordinator?;
+    private publishTimer?;
+    private hasAutoPublish;
+    constructor(workspaceAdapter: WorkspaceAdapter, publishAppService?: PublishAppService);
+    private calculateOverallProgress;
+    private createProgressCallback;
+    startServer(options: ObsidianServeOptions, onProgress?: (progress: ObsidianServeProgress) => void): Promise<ObsidianServeResult>;
+    stopServer(): Promise<boolean>;
+    isRunning(): boolean;
+    private autoPublish;
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspaceAdapter } from '../adapters';
+import type { ObsidianWorkspaceInitOptions, ObsidianWorkspaceInfo, ObsidianWorkspaceResult } from '../types';
+export declare class ObsidianWorkspaceService {
+    private readonly workspaceAdapter;
+    constructor(workspaceAdapter: WorkspaceAdapter);
+    initWorkspace(workspacePath: string, options?: ObsidianWorkspaceInitOptions): Promise<ObsidianWorkspaceResult<ObsidianWorkspaceInfo>>;
+    getWorkspaceInfo(workspacePath: string): Promise<ObsidianWorkspaceResult<ObsidianWorkspaceInfo>>;
+    workspaceExists(workspacePath: string): Promise<ObsidianWorkspaceResult<boolean>>;
+}

package/dist/internal/interfaces/obsidian/types/auth.d.ts

@@ -0,0 +1,27 @@
+export interface ObsidianSyncConfig {
+    dbEndpoint: string;
+    dbName: string;
+    email: string;
+    userDir: string;
+    status: string;
+    isActive: boolean;
+}
+export interface ObsidianAuthStatus {
+    isAuthenticated: boolean;
+    email?: string;
+    serverUrl: string;
+    token?: string;
+    license?: string;
+    hasSyncConfig: boolean;
+    syncConfig?: ObsidianSyncConfig;
+}
+export interface ObsidianServerConfig {
+    apiUrl: string;
+    websiteUrl?: string;
+}
+export interface ObsidianAuthResult<T = void> {
+    success: boolean;
+    message: string;
+    data?: T;
+    error?: string;
+}

package/dist/internal/interfaces/obsidian/{build.d.ts → types/build.d.ts}

@@ -1,4 +1,3 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
 export interface ObsidianBuildOptions {
     workspacePath: string;
     projectNameOrPath: string;
@@ -22,10 +21,3 @@ export interface ObsidianBuildResult {
     };
     error?: string;
 }
-export declare class ObsidianBuildService {
-    private workspaceAppService;
-    constructor(workspaceAppService: WorkspaceAppService);
-    buildProject(options: ObsidianBuildOptions): Promise<ObsidianBuildResult>;
-    private cleanOutputDir;
-}
-export declare function createObsidianBuildService(): ObsidianBuildService;

package/dist/internal/interfaces/obsidian/types/config.d.ts

@@ -0,0 +1,16 @@
+export interface ObsidianConfigResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+export interface ConfigGetResult {
+    key: string;
+    value: any;
+    project?: string;
+}
+export interface ConfigListResult {
+    config: Record<string, any>;
+    scope: 'global' | 'project';
+    project?: string;
+}

package/dist/internal/interfaces/obsidian/{domain.d.ts → types/domain.d.ts}

@@ -1,4 +1,3 @@
-import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianDomainInfo {
     subdomain: string;
     fullDomain: string;
@@ -45,15 +44,3 @@ export interface ObsidianDomainResult<T = void> {
     data?: T;
     error?: string;
 }
-export declare class ObsidianDomainService {
-    private readonly httpClient;
-    constructor(httpClient: HttpClient);
-    private getIdentityService;
-    getDomainInfo(workspacePath: string): Promise<ObsidianDomainResult<ObsidianDomainInfo>>;
-    checkSubdomain(workspacePath: string, subdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainCheckResult>>;
-    updateSubdomain(workspacePath: string, newSubdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainUpdateResult>>;
-    checkCustomDomain(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainCheckResult>>;
-    addCustomDomain(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainAddResult>>;
-    checkHttpsStatus(workspacePath: string, domain: string): Promise<ObsidianDomainResult<ObsidianHttpsStatusResult>>;
-}
-export declare function createObsidianDomainService(httpClient: HttpClient): ObsidianDomainService;

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

@@ -0,0 +1,9 @@
+export * from './auth';
+export * from './license';
+export * from './workspace';
+export * from './config';
+export * from './project';
+export * from './build';
+export * from './serve';
+export * from './publish';
+export * from './domain';

package/dist/internal/interfaces/obsidian/{license.d.ts → types/license.d.ts}

@@ -1,5 +1,3 @@
-import type { ObsidianMobileEnvironmentConfig } from './mobile-config-types';
-import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianLicenseInfo {
     key: string;
     plan: string;
@@ -87,24 +85,3 @@ export interface ObsidianLicenseResult<T = any> {
     data?: T;
     error?: string;
 }
-export declare class ObsidianLicenseService {
-    private readonly httpClient;
-    private readonly config;
-    constructor(httpClient: HttpClient, config?: ObsidianMobileEnvironmentConfig);
-    private getIdentityService;
-    requestTrial(workspacePath: string, email: string): Promise<ObsidianLicenseResult<{
-        email: string;
-        licenseKey: string;
-        password: string;
-        validityDays: number;
-    }>>;
-    requestAndActivateTrial(workspacePath: string, email: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
-    loginWithLicense(workspacePath: string, licenseKey: string): Promise<ObsidianLicenseResult<{}>>;
-    activateLicense(workspacePath: string, licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
-    getLicenseInfo(workspacePath: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
-    getLicenseUsage(workspacePath: string): Promise<ObsidianLicenseResult<ObsidianLicenseUsage>>;
-    resetUsage(workspacePath: string, force: boolean): Promise<ObsidianLicenseResult<any>>;
-    hasActiveLicense(workspacePath: string): Promise<boolean>;
-    private buildLicenseInfo;
-}
-export declare function createObsidianLicenseService(httpClient: HttpClient, config?: ObsidianMobileEnvironmentConfig): ObsidianLicenseService;

package/dist/internal/interfaces/obsidian/{project.d.ts → types/project.d.ts}

@@ -1,4 +1,3 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
 export interface ObsidianProjectCreateOptions {
     name: string;
     workspacePath: string;
@@ -55,19 +54,3 @@ export interface ObsidianFolderStructureInfo {
     defaultLanguage?: string | undefined;
     summary: string;
 }
-export declare class ObsidianProjectService {
-    private workspaceAppService;
-    constructor(workspaceAppService: WorkspaceAppService);
-    createProject(options: ObsidianProjectCreateOptions): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
-    private createProjectFromFile;
-    private createProjectFromFolder;
-    private createEmptyProject;
-    private buildProjectInfo;
-    listProjects(workspacePath: string): Promise<ObsidianProjectResult<ObsidianProjectInfo[]>>;
-    getProjectInfo(workspacePath: string, projectName: string): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
-    deleteProject(workspacePath: string, projectIdOrName: string, options?: {
-        deleteFiles?: boolean;
-    }): Promise<ObsidianProjectResult<void>>;
-    scanFolderStructure(folderPath: string): Promise<ObsidianProjectResult<ObsidianFolderStructureInfo>>;
-}
-export declare function createObsidianProjectService(): ObsidianProjectService;

package/dist/internal/interfaces/obsidian/{publish.d.ts → types/publish.d.ts}

@@ -1,7 +1,4 @@
-import { PublishAppService } from '@internal/application/publish';
-import { WorkspaceAppService } from '@internal/application/workspace';
 import { AnyPublishConfig } from '@internal/domain/publish';
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
 export type ObsidianPublishMethod = 'ftp' | 'netlify' | 'mdfriday';
 export interface ObsidianPublishOptions {
     workspacePath: string;
@@ -34,11 +31,3 @@ export interface ObsidianTestConnectionResult {
     success: boolean;
     error?: string;
 }
-export declare class ObsidianPublishService {
-    private publishAppService;
-    private workspaceAppService;
-    constructor(publishAppService: PublishAppService, workspaceAppService: WorkspaceAppService);
-    publish(options: ObsidianPublishOptions, onProgress?: (progress: ObsidianPublishProgress) => void): Promise<ObsidianPublishResult>;
-    testConnection(workspacePath: string, projectName: string, config: AnyPublishConfig): Promise<ObsidianTestConnectionResult>;
-}
-export declare function createObsidianPublishService(httpClient: HttpClient): ObsidianPublishService;

package/dist/internal/interfaces/obsidian/{serve.d.ts → types/serve.d.ts}

@@ -1,8 +1,5 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
-import { PublishAppService } from '@internal/application/publish';
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
-import { MarkdownRenderer } from '@internal/domain/markdown';
 import { AnyPublishConfig } from '@internal/domain/publish';
+import { MarkdownRenderer } from '@internal/domain/markdown';
 export interface ObsidianServeOptions {
     workspacePath: string;
     projectName: string;
@@ -47,18 +44,3 @@ export interface ObsidianServeProgress {
         method?: 'ftp' | 'netlify' | 'mdfriday';
     };
 }
-export declare class ObsidianServeService {
-    private workspaceAppService;
-    private publishAppService;
-    private coordinator?;
-    private publishTimer?;
-    private hasAutoPublish;
-    constructor(workspaceAppService: WorkspaceAppService, publishAppService?: PublishAppService);
-    private calculateOverallProgress;
-    private createProgressCallback;
-    startServer(options: ObsidianServeOptions, onProgress?: (progress: ObsidianServeProgress) => void): Promise<ObsidianServeResult>;
-    stopServer(): Promise<boolean>;
-    isRunning(): boolean;
-    private autoPublish;
-}
-export declare function createObsidianServeService(httpClient?: HttpClient): ObsidianServeService;

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

@@ -0,0 +1,27 @@
+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;
+}