@mdfriday/foundry 26.2.13 → 26.3.1

package/dist/internal/application/identity.d.ts

@@ -0,0 +1,90 @@
+import { UserFactory } from '@internal/domain/identity/factory/user-factory';
+import { User } from '@internal/domain/identity/entity/user';
+import { ServerConfig } from '@internal/domain/identity/value-object/server-config';
+import { License } from '@internal/domain/identity/value-object/license';
+import { Device } from '@internal/domain/identity/value-object/device';
+export interface IdentityAppServiceOptions {
+    userFactory: UserFactory;
+}
+export declare class IdentityAppService {
+    private userFactory;
+    private currentUser;
+    constructor(options: IdentityAppServiceOptions);
+    initialize(): Promise<void>;
+    login(email: string, password: string): Promise<User>;
+    register(email: string, password: string): Promise<User>;
+    logout(): Promise<void>;
+    getCurrentUser(): User | null;
+    isAuthenticated(): boolean;
+    getToken(): string | null;
+    getStatus(): {
+        isAuthenticated: boolean;
+        email: string;
+        serverUrl: string;
+        tokenExpired: boolean;
+        hasToken: boolean;
+        hasLicense: boolean;
+        licenseValid: boolean;
+        isTrial: boolean;
+        licensePlan: import("@internal/domain/identity/value-object/license").LicensePlan | undefined;
+        licenseExpires: string | undefined;
+        licenseDaysRemaining: number | undefined;
+    } | {
+        isAuthenticated: boolean;
+        email: undefined;
+        serverUrl: string;
+        tokenExpired: boolean;
+        hasToken: boolean;
+    };
+    getServerConfig(): ServerConfig;
+    updateServerConfig(updates: {
+        apiUrl?: string;
+        websiteUrl?: string;
+    }): Promise<void>;
+    requestTrialLicense(email: string): Promise<import("@internal/domain/identity/factory/user-factory").TrialLicenseResponse>;
+    loginWithLicense(licenseKey: string): Promise<User>;
+    activateLicense(licenseKey: string, device?: Device): Promise<User>;
+    requestAndActivateTrial(email: string): Promise<User>;
+    getLicense(): License | null;
+    hasValidLicense(): boolean;
+    isTrialAccount(): boolean;
+    getLicenseDisplay(): {
+        key: string;
+        plan: string;
+        expires: string;
+        daysRemaining: number;
+        isValid: boolean;
+        isExpired: boolean;
+        isTrial: boolean;
+        features: import("@internal/domain/identity/value-object/license").LicenseFeatures;
+    } | null;
+    refreshTokenIfNeeded(): Promise<boolean>;
+    requestWithAutoRefresh<T>(requestFn: (tokenValue: string) => Promise<T>): Promise<T>;
+    getLicenseUsage(): Promise<import("@internal/domain/identity/factory/user-factory").LicenseUsageResponse | null>;
+    getLicenseInfo(licenseKey?: string): Promise<any>;
+    resetUsage(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    getDomains(): Promise<import("@internal/domain/identity/factory/user-factory").DomainInfo | null>;
+    checkSubdomainAvailability(subdomain: string): Promise<import("@internal/domain/identity/factory/user-factory").SubdomainCheckResponse | null>;
+    updateSubdomain(newSubdomain: string): Promise<import("@internal/domain/identity/factory/user-factory").SubdomainUpdateResponse | null>;
+    checkCustomDomain(domain: string): Promise<{
+        dns_valid: boolean;
+        ready: boolean;
+        message: string;
+        resolved_ips?: string[];
+    } | null>;
+    addCustomDomain(domain: string): Promise<{
+        domain: string;
+        status: string;
+        message: string;
+    } | null>;
+    checkCustomDomainHttpsStatus(domain: string): Promise<{
+        status: string;
+        tls_ready: boolean;
+        dns_valid: boolean;
+        message: string;
+        certificate?: any;
+    } | null>;
+}

package/dist/internal/application/incremental-build-coordinator.d.ts

@@ -13,6 +13,7 @@ export interface IncrementalBuildConfig {
     progressCallback?: SSGProgressCallback;
     markdown?: MarkdownRenderer;
     httpClient?: HttpClient;
+    onSuccess?: () => void | Promise<void>;
     liveReload?: {
         enabled?: boolean;
         port?: number;

package/dist/internal/application/publish.d.ts

@@ -0,0 +1,28 @@
+import { PublisherFactory } from '@internal/domain/publish';
+import { WorkspaceAppService } from './workspace';
+import { Project } from '@internal/domain/workspace';
+export interface PublishOptions {
+    force?: boolean;
+    incremental?: boolean;
+    config?: any;
+}
+export type PublishProgressCallback = (progress: {
+    phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
+    percentage: number;
+    message: string;
+    currentFile?: string;
+    filesCompleted?: number;
+    filesTotal?: number;
+    bytesTransferred?: number;
+}) => void;
+export declare class PublishAppService {
+    private publisherFactory;
+    private workspaceService;
+    constructor(publisherFactory: PublisherFactory, workspaceService: WorkspaceAppService);
+    publish(project: Project, method: 'ftp' | 'netlify' | 'mdfriday', options?: PublishOptions, onProgress?: PublishProgressCallback): Promise<any>;
+    testConnection(project: Project, method: 'ftp' | 'netlify' | 'mdfriday'): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    private getMethodConfig;
+}

package/dist/internal/application/workspace.d.ts

@@ -0,0 +1,29 @@
+import { WorkspaceFactory, Workspace, Project } from '@internal/domain/workspace';
+export interface WorkspaceAppServiceOptions {
+    workspaceFactory: WorkspaceFactory;
+}
+export declare class WorkspaceAppService {
+    private workspaceFactory;
+    constructor(options: WorkspaceAppServiceOptions);
+    loadWorkspace(path?: string): Promise<Workspace>;
+    createWorkspace(path: string, options?: Parameters<WorkspaceFactory['create']>[1]): Promise<Workspace>;
+    saveWorkspace(workspace: Workspace): Promise<void>;
+    findWorkspaceRoot(startPath?: string): Promise<string | null>;
+    createProject(workspace: Workspace, name: string, options?: Parameters<WorkspaceFactory['createProject']>[2]): Promise<Project>;
+    createProjectFromFolder(workspace: Workspace, name: string, sourceFolderPath: string, options?: Parameters<WorkspaceFactory['createProjectFromFolder']>[3]): Promise<Project>;
+    createProjectFromFile(workspace: Workspace, name: string, sourceFilePath: string, options?: Parameters<WorkspaceFactory['createProjectFromFile']>[3]): Promise<Project>;
+    deleteProject(workspace: Workspace, projectIdOrName: string, options?: Parameters<WorkspaceFactory['deleteProject']>[2]): Promise<void>;
+    loadWorkspaceAndProject(projectNameOrPath?: string, workspacePath?: string): Promise<{
+        workspace: Workspace;
+        project: Project;
+    }>;
+    createSnapshot(project: Project, snapshotName?: string): Promise<import("@internal/domain/workspace").SnapshotMetadata>;
+    listSnapshots(project: Project): Promise<import("@internal/domain/workspace").SnapshotMetadata[]>;
+    restoreSnapshot(project: Project, snapshotId: string, outputDir?: string): Promise<void>;
+    deleteSnapshot(project: Project, snapshotId: string): Promise<void>;
+    getSnapshot(project: Project, snapshotId: string): Promise<import("@internal/domain/workspace").SnapshotMetadata>;
+    loadProject(projectPath: string): Promise<Project>;
+    saveProject(project: Project): Promise<void>;
+    findProjectRoot(startPath: string): Promise<string | null>;
+    createIdentityStorage(workspace: Workspace): import("../domain/identity").IdentityStorageProvider;
+}

package/dist/internal/domain/identity/entity/user.d.ts

@@ -0,0 +1,55 @@
+import { Email } from '../value-object/email';
+import { Token } from '../value-object/token';
+import { ServerConfig } from '../value-object/server-config';
+import { License } from '../value-object/license';
+export declare class User {
+    private readonly email;
+    private token;
+    private serverConfig;
+    private license;
+    constructor(email: Email, token: Token | null, serverConfig: ServerConfig, license?: License | null);
+    getEmail(): Email;
+    getToken(): Token | null;
+    getServerConfig(): ServerConfig;
+    getLicense(): License | null;
+    setToken(token: Token): void;
+    clearToken(): void;
+    updateServerConfig(config: ServerConfig): void;
+    setLicense(license: License): void;
+    clearLicense(): void;
+    isAuthenticated(): boolean;
+    isTokenExpired(): boolean;
+    hasValidLicense(): boolean;
+    isTrialAccount(): boolean;
+    getStatus(): {
+        isAuthenticated: boolean;
+        email: string;
+        serverUrl: string;
+        tokenExpired: boolean;
+        hasToken: boolean;
+        hasLicense: boolean;
+        licenseValid: boolean;
+        isTrial: boolean;
+        licensePlan: import("../value-object/license").LicensePlan | undefined;
+        licenseExpires: string | undefined;
+        licenseDaysRemaining: number | undefined;
+    };
+    toJSON(): {
+        email: string;
+        token: {
+            token: string;
+            expiresAt?: number;
+        } | null;
+        serverConfig: {
+            apiUrl: string;
+            websiteUrl?: string;
+        };
+        license: {
+            key: string;
+            plan: import("../value-object/license").LicensePlan;
+            expiresAt: number;
+            features: import("../value-object/license").LicenseFeatures;
+            activatedAt: number;
+        } | null;
+    };
+}

package/dist/internal/domain/identity/factory/user-factory.d.ts

@@ -0,0 +1,153 @@
+import { User } from '../entity/user';
+import { ServerConfig } from '../value-object/server-config';
+import { Device } from '../value-object/device';
+import { HttpClient, IdentityStorageProvider } from '../repository/index';
+export interface TrialLicenseResponse {
+    email: string;
+    license_key: string;
+    password: string;
+    message: string;
+    success: boolean;
+    validity_days: number;
+}
+export interface LicenseActivationResponse {
+    activated: boolean;
+    first_time: boolean;
+    expires_at: number;
+    features: {
+        max_devices: number;
+        max_ips: number;
+        sync_enabled: boolean;
+        sync_quota: number;
+        publish_enabled: boolean;
+        max_sites: number;
+        max_storage: number;
+        custom_domain: boolean;
+        custom_sub_domain: boolean;
+        validity_days: number;
+    };
+    license_key: string;
+    plan: string;
+    success: boolean;
+    user: {
+        email: string;
+        user_dir: string;
+    };
+}
+export interface DomainInfo {
+    subdomain: string;
+    full_domain: string;
+    cus_domain: string;
+    folder: string;
+    created_at: number;
+}
+export interface SubdomainCheckResponse {
+    available: boolean;
+    message?: string;
+}
+export interface SubdomainUpdateResponse {
+    new_subdomain: string;
+    old_subdomain: string;
+    full_domain: string;
+    message: string;
+}
+export interface UserFactoryOptions {
+    httpClient: HttpClient;
+    storageProvider: IdentityStorageProvider;
+}
+export declare class UserFactory {
+    private httpClient;
+    private storageProvider;
+    constructor(options: UserFactoryOptions);
+    createAnonymous(serverConfig?: ServerConfig): User;
+    load(): Promise<User | null>;
+    save(user: User): Promise<void>;
+    loadServerConfig(): Promise<ServerConfig | null>;
+    login(email: string, password: string, serverConfig?: ServerConfig): Promise<User>;
+    register(email: string, password: string, serverConfig?: ServerConfig): Promise<User>;
+    logout(): Promise<void>;
+    updateServerConfig(user: User, updates: {
+        apiUrl?: string;
+        websiteUrl?: string;
+    }): Promise<void>;
+    requestTrialLicense(email: string, serverConfig?: ServerConfig): Promise<TrialLicenseResponse>;
+    loginWithLicense(licenseKey: string, serverConfig?: ServerConfig): Promise<User>;
+    activateLicense(user: User, licenseKey: string, device?: Device): Promise<User>;
+    requestAndActivateTrial(email: string, serverConfig?: ServerConfig): Promise<User>;
+    refreshTokenIfNeeded(user: User): Promise<User>;
+    requestWithAutoRefresh<T>(user: User, requestFn: (tokenValue: string) => Promise<T>): Promise<T>;
+    getLicenseUsage(user: User): Promise<LicenseUsageResponse | null>;
+    getLicenseInfo(user: User, licenseKey?: string): Promise<any>;
+    resetUsage(user: User): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    getDomains(user: User): Promise<DomainInfo | null>;
+    checkSubdomainAvailability(user: User, subdomain: string): Promise<SubdomainCheckResponse | null>;
+    updateSubdomain(user: User, newSubdomain: string): Promise<SubdomainUpdateResponse | null>;
+    checkCustomDomain(user: User, domain: string): Promise<{
+        dns_valid: boolean;
+        ready: boolean;
+        message: string;
+        resolved_ips?: string[];
+    } | null>;
+    addCustomDomain(user: User, domain: string): Promise<{
+        domain: string;
+        status: string;
+        message: string;
+    } | null>;
+    checkCustomDomainHttpsStatus(user: User, domain: string): Promise<{
+        status: string;
+        tls_ready: boolean;
+        dns_valid: boolean;
+        message: string;
+        certificate?: any;
+    } | null>;
+}
+export interface LicenseUsageResponse {
+    devices: {
+        count: number;
+        devices: Array<{
+            access_count: number;
+            device_id: string;
+            device_name: string;
+            device_type: string;
+            first_seen_at: number;
+            last_seen_at: number;
+            status: string;
+        }>;
+    };
+    disks: {
+        sync_disk_usage: string;
+        publish_disk_usage: string;
+        total_disk_usage: string;
+        unit: string;
+    };
+    features: {
+        max_devices: number;
+        max_ips: number;
+        sync_enabled: boolean;
+        sync_quota: number;
+        publish_enabled: boolean;
+        max_sites: number;
+        max_storage: number;
+        custom_domain: boolean;
+        custom_sub_domain: boolean;
+        validity_days: number;
+    };
+    ips: {
+        count: number;
+        ips: Array<{
+            access_count: number;
+            city: string;
+            country: string;
+            first_seen_at: number;
+            ip_address: string;
+            last_seen_at: number;
+            region: string;
+            status: string;
+        }>;
+    };
+    license_key: string;
+    plan: string;
+}

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

@@ -0,0 +1,9 @@
+export { Email } from './value-object/email';
+export { Token } from './value-object/token';
+export { ServerConfig } from './value-object/server-config';
+export { License, LicenseFeatures, LicensePlan } from './value-object/license';
+export { Device, DeviceType } from './value-object/device';
+export { User } from './entity/user';
+export { UserFactory, UserFactoryOptions } from './factory/user-factory';
+export type { IdentityStorageProvider, HttpClient, HttpResponse } from './repository/index';
+export * from './type';

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

@@ -0,0 +1,31 @@
+export interface 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>;
+}
+export interface HttpResponse {
+    status: number;
+    data: any;
+    text(): Promise<string>;
+}
+export interface IdentityStorageProvider {
+    saveUserData(data: {
+        token?: any;
+        license?: any;
+        serverConfig: any;
+        email?: string;
+    }): Promise<void>;
+    loadUserData(): Promise<{
+        token?: any;
+        license?: any;
+        serverConfig?: any;
+        email?: string;
+    } | null>;
+    clearUserData(): Promise<void>;
+    saveToken(token: any): Promise<void>;
+    loadToken(): Promise<any | null>;
+    clearToken(): Promise<void>;
+    saveServerConfig(config: any): Promise<void>;
+    loadServerConfig(): Promise<any | null>;
+}

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

@@ -0,0 +1,19 @@
+export interface UserCredentials {
+    email: string;
+    password: string;
+}
+export interface UserProfile {
+    email: string;
+    name?: string;
+    avatar?: string;
+}
+export interface LoginResponse {
+    token: string;
+    expiresAt?: number;
+    user?: UserProfile;
+}
+export interface RegisterResponse {
+    token: string;
+    expiresAt?: number;
+    user?: UserProfile;
+}

package/dist/internal/domain/identity/value-object/device.d.ts

@@ -0,0 +1,21 @@
+export type DeviceType = 'desktop' | 'mobile' | 'tablet';
+export declare class Device {
+    private readonly id;
+    private readonly name;
+    private readonly type;
+    private constructor();
+    static create(id: string, name: string, type: DeviceType): Device;
+    static createFromEnvironment(): Promise<Device>;
+    private static generateFingerprint;
+    private static getDeviceName;
+    private static getDeviceType;
+    getId(): string;
+    getName(): string;
+    getType(): DeviceType;
+    equals(other: Device): boolean;
+    toJSON(): {
+        id: string;
+        name: string;
+        type: DeviceType;
+    };
+}

package/dist/internal/domain/identity/value-object/email.d.ts

@@ -0,0 +1,12 @@
+export declare class Email {
+    private readonly value;
+    private constructor();
+    static create(email: string): Email;
+    static isValid(email: string): boolean;
+    getValue(): string;
+    getDomain(): string;
+    getLocalPart(): string;
+    equals(other: Email): boolean;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/internal/domain/identity/value-object/license.d.ts

@@ -0,0 +1,63 @@
+export interface LicenseFeatures {
+    maxDevices: number;
+    maxIps: number;
+    syncEnabled: boolean;
+    syncQuota: number;
+    publishEnabled: boolean;
+    maxSites: number;
+    maxStorage: number;
+    customDomain: boolean;
+    customSubDomain: boolean;
+    validityDays: number;
+}
+export type LicensePlan = 'trial' | 'basic' | 'pro' | 'enterprise' | 'lifetime';
+export declare class License {
+    private readonly key;
+    private readonly plan;
+    private readonly expiresAt;
+    private readonly features;
+    private readonly activatedAt;
+    private constructor();
+    static create(key: string, plan: LicensePlan, expiresAt: number, features: LicenseFeatures, activatedAt?: number): License;
+    static fromJSON(data: {
+        key: string;
+        plan: LicensePlan;
+        expiresAt: number;
+        features: LicenseFeatures;
+        activatedAt: number;
+    }): License;
+    static isValidFormat(key: string): boolean;
+    isExpired(): boolean;
+    isValid(): boolean;
+    getDaysRemaining(): number;
+    getEmail(): string;
+    getPassword(): string;
+    private manualBase64Encode;
+    getKey(): string;
+    getMaskedKey(): string;
+    getPlan(): LicensePlan;
+    getFormattedPlan(): string;
+    getExpiresAt(): number;
+    getFormattedExpiresAt(): string;
+    getFeatures(): LicenseFeatures;
+    getActivatedAt(): number;
+    isTrial(): boolean;
+    equals(other: License): boolean;
+    toJSON(): {
+        key: string;
+        plan: LicensePlan;
+        expiresAt: number;
+        features: LicenseFeatures;
+        activatedAt: number;
+    };
+    toStorageFormat(): {
+        key: string;
+        maskedKey: string;
+        plan: string;
+        expiresAt: number;
+        features: LicenseFeatures;
+        activatedAt: number;
+        isValid: boolean;
+        daysRemaining: number;
+    };
+}

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

@@ -0,0 +1,21 @@
+export declare class ServerConfig {
+    private readonly apiUrl;
+    private readonly websiteUrl;
+    private constructor();
+    static create(apiUrl: string, websiteUrl?: string): ServerConfig;
+    static fromJSON(data: {
+        apiUrl: string;
+        websiteUrl?: string;
+    }): ServerConfig;
+    static createDefault(): ServerConfig;
+    private static isValidUrl;
+    getApiUrl(): string;
+    getWebsiteUrl(): string | undefined;
+    withApiUrl(apiUrl: string): ServerConfig;
+    withWebsiteUrl(websiteUrl?: string): ServerConfig;
+    equals(other: ServerConfig): boolean;
+    toJSON(): {
+        apiUrl: string;
+        websiteUrl?: string;
+    };
+}

package/dist/internal/domain/identity/value-object/token.d.ts

@@ -0,0 +1,21 @@
+export declare class Token {
+    private readonly value;
+    private readonly expiresAt;
+    private constructor();
+    static create(value: string, expiresAt?: number): Token;
+    static fromJSON(data: {
+        token: string;
+        expiresAt?: number;
+    }): Token;
+    getValue(): string;
+    getExpiresAt(): number | undefined;
+    isExpired(): boolean;
+    isValid(): boolean;
+    getRemainingTime(): number | null;
+    equals(other: Token): boolean;
+    toString(): string;
+    toJSON(): {
+        token: string;
+        expiresAt?: number;
+    };
+}

package/dist/internal/domain/publish/entity/publisher.d.ts

@@ -0,0 +1,24 @@
+import { Publisher, PublishType, AnyPublishConfig, PublishResult, PublishProgressCallback } from '../type';
+import { ManifestRepository } from '../repository/manifest-repository';
+export declare class PublisherAggregator implements Publisher {
+    private readonly projectId;
+    private readonly projectPath;
+    private readonly config;
+    private readonly strategy;
+    private readonly manifestRepo;
+    constructor(projectId: string, projectPath: string, config: AnyPublishConfig, strategy: Publisher, manifestRepo: ManifestRepository);
+    publish(sourceDir: string, options?: {
+        incremental?: boolean;
+        force?: boolean;
+        onProgress?: PublishProgressCallback;
+    }): Promise<PublishResult>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getConfig(): AnyPublishConfig;
+    getType(): PublishType;
+    getProjectId(): string;
+    getProjectPath(): string;
+    private getRemoteConfig;
+}

package/dist/internal/domain/publish/factory/publisher-factory.d.ts

@@ -0,0 +1,13 @@
+import { PublisherAggregator } from '../entity/publisher';
+import { AnyPublishConfig } from '../type';
+import { ManifestRepository } from '../repository/manifest-repository';
+import { HttpClient } from '../repository/http-client';
+export declare class PublisherFactory {
+    private readonly manifestRepo;
+    private readonly httpClient;
+    constructor(manifestRepo: ManifestRepository, httpClient: HttpClient);
+    create(projectId: string, projectPath: string, config: AnyPublishConfig): PublisherAggregator;
+    private createFtpPublisher;
+    private createNetlifyPublisher;
+    private createMDFridayPublisher;
+}

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

@@ -0,0 +1,10 @@
+export * from './type';
+export * from './entity/publisher';
+export * from './value-object/publish-manifest';
+export * from './value-object/publish-config';
+export * from './value-object/ftp-publisher';
+export * from './value-object/netlify-publisher';
+export * from './value-object/mdfriday-publisher';
+export * from './factory/publisher-factory';
+export * from './repository/manifest-repository';
+export * from './repository/http-client';

package/dist/internal/domain/publish/repository/http-client.d.ts

@@ -0,0 +1,14 @@
+export interface 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>;
+}
+export interface HttpResponse {
+    status: number;
+    ok: boolean;
+    statusText?: string;
+    data: any;
+    text(): Promise<string>;
+    json(): Promise<any>;
+}

package/dist/internal/domain/publish/repository/manifest-repository.d.ts

@@ -0,0 +1,7 @@
+import { PublishManifest } from '../value-object/publish-manifest';
+export interface 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>;
+}