eh-downloader/frontend/wailsjs/go/models.ts

export namespace core {
	
	export class FailedItem {
	    page: number;
	    file: string;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new FailedItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.file = source["file"];
	        this.error = source["error"];
	    }
	}
	export class PushedEntry {
	    gid: string;
	    token?: string;
	    title?: string;
	    pushedAt: number;
	    completed?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new PushedEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.gid = source["gid"];
	        this.token = source["token"];
	        this.title = source["title"];
	        this.pushedAt = source["pushedAt"];
	        this.completed = source["completed"];
	    }
	}
	export class Settings {
	    downloadRoot: string;
	    proxy: string;
	    proxyMode: string;
	    galleryConcurrency: number;
	    pageConcurrency: number;
	    requestIntervalMs: number;
	    timeout: number;
	    xres: string;
	    bridgePort: number;
	    dirTemplate: string;
	    _probed: boolean;
	
	    static createFrom(source: any = {}) {
	        return new Settings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.downloadRoot = source["downloadRoot"];
	        this.proxy = source["proxy"];
	        this.proxyMode = source["proxyMode"];
	        this.galleryConcurrency = source["galleryConcurrency"];
	        this.pageConcurrency = source["pageConcurrency"];
	        this.requestIntervalMs = source["requestIntervalMs"];
	        this.timeout = source["timeout"];
	        this.xres = source["xres"];
	        this.bridgePort = source["bridgePort"];
	        this.dirTemplate = source["dirTemplate"];
	        this._probed = source["_probed"];
	    }
	}
	export class Task {
	    gid: string;
	    token: string;
	    raw: string;
	    title: string;
	    status: string;
	    done: number;
	    failed: number;
	    totalPages: number;
	    error: string;
	    dir: string;
	    pages: Record<string, string>;
	    failedList: FailedItem[];
	    selected: boolean;
	    createdAt: number;
	    updatedAt: number;
	
	    static createFrom(source: any = {}) {
	        return new Task(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.gid = source["gid"];
	        this.token = source["token"];
	        this.raw = source["raw"];
	        this.title = source["title"];
	        this.status = source["status"];
	        this.done = source["done"];
	        this.failed = source["failed"];
	        this.totalPages = source["totalPages"];
	        this.error = source["error"];
	        this.dir = source["dir"];
	        this.pages = source["pages"];
	        this.failedList = this.convertValues(source["failedList"], FailedItem);
	        this.selected = source["selected"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}

}

export namespace main {
	
	export class AddTasksResult {
	    added: number;
	    skipped: number;
	    warning: string;
	
	    static createFrom(source: any = {}) {
	        return new AddTasksResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.added = source["added"];
	        this.skipped = source["skipped"];
	        this.warning = source["warning"];
	    }
	}
	export class DirPreviewResult {
	    ok: boolean;
	    path: string;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new DirPreviewResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ok = source["ok"];
	        this.path = source["path"];
	        this.error = source["error"];
	    }
	}
	export class EngineInfo {
	    running: boolean;
	    queued: number;
	    galleryConcurrency: number;
	    pageConcurrency: number;
	    maxConcurrent: number;
	    requestIntervalMs: number;
	
	    static createFrom(source: any = {}) {
	        return new EngineInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.running = source["running"];
	        this.queued = source["queued"];
	        this.galleryConcurrency = source["galleryConcurrency"];
	        this.pageConcurrency = source["pageConcurrency"];
	        this.maxConcurrent = source["maxConcurrent"];
	        this.requestIntervalMs = source["requestIntervalMs"];
	    }
	}
	export class PushedHistoryResult {
	    count: number;
	    items: core.PushedEntry[];
	
	    static createFrom(source: any = {}) {
	        return new PushedHistoryResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.items = this.convertValues(source["items"], core.PushedEntry);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ScanManifestsResult {
	    found: number;
	    adopted: number;
	    root: string;
	    note: string;
	
	    static createFrom(source: any = {}) {
	        return new ScanManifestsResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.found = source["found"];
	        this.adopted = source["adopted"];
	        this.root = source["root"];
	        this.note = source["note"];
	    }
	}
	export class StartResult {
	    started: boolean;
	    reason: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new StartResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.started = source["started"];
	        this.reason = source["reason"];
	        this.count = source["count"];
	    }
	}
	export class StatusResult {
	    running: boolean;
	    queued: number;
	
	    static createFrom(source: any = {}) {
	        return new StatusResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.running = source["running"];
	        this.queued = source["queued"];
	    }
	}

}