export namespace main {
	
	export class BootstrapStatus {
	    state: string;
	    databasePath: string;
	    defaultPath: string;
	    errorCode?: string;
	    errorDetail?: string;
	
	    static createFrom(source: any = {}) {
	        return new BootstrapStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.state = source["state"];
	        this.databasePath = source["databasePath"];
	        this.defaultPath = source["defaultPath"];
	        this.errorCode = source["errorCode"];
	        this.errorDetail = source["errorDetail"];
	    }
	}

}

export namespace model {
	
	export class AppSettings {
	    theme: string;
	    locale: string;
	    gitScope: string;
	    databasePath: string;
	    autoRefresh: boolean;
	    glassOpacity: number;
	    loadingStyle: string;
	
	    static createFrom(source: any = {}) {
	        return new AppSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.theme = source["theme"];
	        this.locale = source["locale"];
	        this.gitScope = source["gitScope"];
	        this.databasePath = source["databasePath"];
	        this.autoRefresh = source["autoRefresh"];
	        this.glassOpacity = source["glassOpacity"];
	        this.loadingStyle = source["loadingStyle"];
	    }
	}
	export class CheckoutResult {
	    branch: string;
	    message: string;
	
	    static createFrom(source: any = {}) {
	        return new CheckoutResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.branch = source["branch"];
	        this.message = source["message"];
	    }
	}
	export class Contributor {
	    name: string;
	    email: string;
	    commits: number;
	    added: number;
	    deleted: number;
	
	    static createFrom(source: any = {}) {
	        return new Contributor(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.email = source["email"];
	        this.commits = source["commits"];
	        this.added = source["added"];
	        this.deleted = source["deleted"];
	    }
	}
	export class Dashboard {
	    projects: number;
	    totalLines: number;
	    commits: number;
	
	    static createFrom(source: any = {}) {
	        return new Dashboard(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.projects = source["projects"];
	        this.totalLines = source["totalLines"];
	        this.commits = source["commits"];
	    }
	}
	export class ExclusionRule {
	    id: number;
	    pattern: string;
	    category: string;
	    builtin: boolean;
	
	    static createFrom(source: any = {}) {
	        return new ExclusionRule(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.pattern = source["pattern"];
	        this.category = source["category"];
	        this.builtin = source["builtin"];
	    }
	}
	export class ExtensionStat {
	    extension: string;
	    files: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new ExtensionStat(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.extension = source["extension"];
	        this.files = source["files"];
	        this.size = source["size"];
	    }
	}
	export class FileEntry {
	    path: string;
	    name: string;
	    extension: string;
	    size: number;
	    isDir: boolean;
	    parent: string;
	
	    static createFrom(source: any = {}) {
	        return new FileEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.name = source["name"];
	        this.extension = source["extension"];
	        this.size = source["size"];
	        this.isDir = source["isDir"];
	        this.parent = source["parent"];
	    }
	}
	export class FolderStat {
	    name: string;
	    files: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new FolderStat(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.files = source["files"];
	        this.size = source["size"];
	    }
	}
	export class GitCommit {
	    hash: string;
	    author: string;
	    email: string;
	    message: string;
	    date: string;
	    added: number;
	    deleted: number;
	
	    static createFrom(source: any = {}) {
	        return new GitCommit(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.hash = source["hash"];
	        this.author = source["author"];
	        this.email = source["email"];
	        this.message = source["message"];
	        this.date = source["date"];
	        this.added = source["added"];
	        this.deleted = source["deleted"];
	    }
	}
	export class GitFileChange {
	    path: string;
	    status: string;
	    added: number;
	    deleted: number;
	
	    static createFrom(source: any = {}) {
	        return new GitFileChange(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.status = source["status"];
	        this.added = source["added"];
	        this.deleted = source["deleted"];
	    }
	}
	export class GitCommitDetail {
	    hash: string;
	    author: string;
	    email: string;
	    message: string;
	    date: string;
	    added: number;
	    deleted: number;
	    files: GitFileChange[];
	
	    static createFrom(source: any = {}) {
	        return new GitCommitDetail(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.hash = source["hash"];
	        this.author = source["author"];
	        this.email = source["email"];
	        this.message = source["message"];
	        this.date = source["date"];
	        this.added = source["added"];
	        this.deleted = source["deleted"];
	        this.files = this.convertValues(source["files"], GitFileChange);
	    }
	
		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 GitDiagnostics {
	    available: boolean;
	    errorCode?: string;
	    detail?: string;
	    isWsl: boolean;
	    distro?: string;
	    linuxPath?: string;
	    workspaceBranch?: string;
	    viewRef?: string;
	    refCount: number;
	
	    static createFrom(source: any = {}) {
	        return new GitDiagnostics(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.errorCode = source["errorCode"];
	        this.detail = source["detail"];
	        this.isWsl = source["isWsl"];
	        this.distro = source["distro"];
	        this.linuxPath = source["linuxPath"];
	        this.workspaceBranch = source["workspaceBranch"];
	        this.viewRef = source["viewRef"];
	        this.refCount = source["refCount"];
	    }
	}
	
	export class GitRef {
	    name: string;
	    hash: string;
	    kind: string;
	    current: boolean;
	
	    static createFrom(source: any = {}) {
	        return new GitRef(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.hash = source["hash"];
	        this.kind = source["kind"];
	        this.current = source["current"];
	    }
	}
	export class HeatDay {
	    date: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new HeatDay(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.date = source["date"];
	        this.count = source["count"];
	    }
	}
	export class GitStats {
	    available: boolean;
	    error?: string;
	    currentBranch: string;
	    workspaceBranch: string;
	    viewRef: string;
	    commitCount: number;
	    added: number;
	    deleted: number;
	    contributorCount: number;
	    commits: GitCommit[];
	    refs: GitRef[];
	    contributors: Contributor[];
	    heatmap: HeatDay[];
	
	    static createFrom(source: any = {}) {
	        return new GitStats(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.error = source["error"];
	        this.currentBranch = source["currentBranch"];
	        this.workspaceBranch = source["workspaceBranch"];
	        this.viewRef = source["viewRef"];
	        this.commitCount = source["commitCount"];
	        this.added = source["added"];
	        this.deleted = source["deleted"];
	        this.contributorCount = source["contributorCount"];
	        this.commits = this.convertValues(source["commits"], GitCommit);
	        this.refs = this.convertValues(source["refs"], GitRef);
	        this.contributors = this.convertValues(source["contributors"], Contributor);
	        this.heatmap = this.convertValues(source["heatmap"], HeatDay);
	    }
	
		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 InsightIssue {
	    severity: string;
	    type: string;
	    title: string;
	    detail: string;
	    path?: string;
	    line?: number;
	    suggestion: string;
	    evidence?: string;
	
	    static createFrom(source: any = {}) {
	        return new InsightIssue(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.severity = source["severity"];
	        this.type = source["type"];
	        this.title = source["title"];
	        this.detail = source["detail"];
	        this.path = source["path"];
	        this.line = source["line"];
	        this.suggestion = source["suggestion"];
	        this.evidence = source["evidence"];
	    }
	}
	export class InsightSummary {
	    high: number;
	    medium: number;
	    low: number;
	    todoCount: number;
	    longFiles: number;
	    largeFiles: number;
	
	    static createFrom(source: any = {}) {
	        return new InsightSummary(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.high = source["high"];
	        this.medium = source["medium"];
	        this.low = source["low"];
	        this.todoCount = source["todoCount"];
	        this.longFiles = source["longFiles"];
	        this.largeFiles = source["largeFiles"];
	    }
	}
	export class LanguageStat {
	    name: string;
	    files: number;
	    code: number;
	    comments: number;
	    blanks: number;
	
	    static createFrom(source: any = {}) {
	        return new LanguageStat(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.files = source["files"];
	        this.code = source["code"];
	        this.comments = source["comments"];
	        this.blanks = source["blanks"];
	    }
	}
	export class LogEntry {
	    id: number;
	    level: string;
	    category: string;
	    message: string;
	    detail: string;
	    createdAt: string;
	
	    static createFrom(source: any = {}) {
	        return new LogEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.level = source["level"];
	        this.category = source["category"];
	        this.message = source["message"];
	        this.detail = source["detail"];
	        this.createdAt = source["createdAt"];
	    }
	}
	export class ProjectStats {
	    totalLines: number;
	    codeLines: number;
	    commentLines: number;
	    blankLines: number;
	    fileCount: number;
	    commitCount: number;
	    addedLines: number;
	    deletedLines: number;
	    contributorCount: number;
	    lastAnalyzed: string;
	
	    static createFrom(source: any = {}) {
	        return new ProjectStats(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.totalLines = source["totalLines"];
	        this.codeLines = source["codeLines"];
	        this.commentLines = source["commentLines"];
	        this.blankLines = source["blankLines"];
	        this.fileCount = source["fileCount"];
	        this.commitCount = source["commitCount"];
	        this.addedLines = source["addedLines"];
	        this.deletedLines = source["deletedLines"];
	        this.contributorCount = source["contributorCount"];
	        this.lastAnalyzed = source["lastAnalyzed"];
	    }
	}
	export class Project {
	    id: number;
	    name: string;
	    path: string;
	    description: string;
	    groupId: number;
	    groupName: string;
	    createdAt: string;
	    updatedAt: string;
	    stats: ProjectStats;
	    languages: LanguageStat[];
	
	    static createFrom(source: any = {}) {
	        return new Project(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.path = source["path"];
	        this.description = source["description"];
	        this.groupId = source["groupId"];
	        this.groupName = source["groupName"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.stats = this.convertValues(source["stats"], ProjectStats);
	        this.languages = this.convertValues(source["languages"], LanguageStat);
	    }
	
		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 ProjectGroup {
	    id: number;
	    name: string;
	    createdAt: string;
	    updatedAt: string;
	
	    static createFrom(source: any = {}) {
	        return new ProjectGroup(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	    }
	}
	export class ProjectInput {
	    name: string;
	    path: string;
	    description: string;
	    groupId: number;
	
	    static createFrom(source: any = {}) {
	        return new ProjectInput(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.path = source["path"];
	        this.description = source["description"];
	        this.groupId = source["groupId"];
	    }
	}
	export class ProjectInsights {
	    projectId: number;
	    healthScore: number;
	    generatedAt: string;
	    summary: InsightSummary;
	    issues: InsightIssue[];
	
	    static createFrom(source: any = {}) {
	        return new ProjectInsights(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.projectId = source["projectId"];
	        this.healthScore = source["healthScore"];
	        this.generatedAt = source["generatedAt"];
	        this.summary = this.convertValues(source["summary"], InsightSummary);
	        this.issues = this.convertValues(source["issues"], InsightIssue);
	    }
	
		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 StructureStats {
	    files: FileEntry[];
	    totalFiles: number;
	    totalDirs: number;
	    totalSize: number;
	    largeFiles: FileEntry[];
	    folders: FolderStat[];
	    extensions: ExtensionStat[];
	
	    static createFrom(source: any = {}) {
	        return new StructureStats(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.files = this.convertValues(source["files"], FileEntry);
	        this.totalFiles = source["totalFiles"];
	        this.totalDirs = source["totalDirs"];
	        this.totalSize = source["totalSize"];
	        this.largeFiles = this.convertValues(source["largeFiles"], FileEntry);
	        this.folders = this.convertValues(source["folders"], FolderStat);
	        this.extensions = this.convertValues(source["extensions"], ExtensionStat);
	    }
	
		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;
		}
	}

}