export namespace application {

	export class Point {
	    x: number;
	    y: number;

	    static createFrom(source: any = {}) {
	        return new Point(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.x = source["x"];
	        this.y = source["y"];
	    }
	}
	export class Annotation {
	    tool: string;
	    color: string;
	    points: Point[];
	    text?: string;

	    static createFrom(source: any = {}) {
	        return new Annotation(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.tool = source["tool"];
	        this.color = source["color"];
	        this.points = this.convertValues(source["points"], Point);
	        this.text = source["text"];
	    }

		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 domain {

	export class OCRProviderConfig {
	    label: string;
	    endpoint: string;
	    accessKeyId: string;
	    accessKeySecret: string;
	    region: string;
	    service: string;
	    action: string;
	    version: string;
	    timeoutSecs: number;

	    static createFrom(source: any = {}) {
	        return new OCRProviderConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.endpoint = source["endpoint"];
	        this.accessKeyId = source["accessKeyId"];
	        this.accessKeySecret = source["accessKeySecret"];
	        this.region = source["region"];
	        this.service = source["service"];
	        this.action = source["action"];
	        this.version = source["version"];
	        this.timeoutSecs = source["timeoutSecs"];
	    }
	}
	export class OCRConfig {
	    activeProvider: string;
	    providers: Record<string, OCRProviderConfig>;

	    static createFrom(source: any = {}) {
	        return new OCRConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.activeProvider = source["activeProvider"];
	        this.providers = this.convertValues(source["providers"], OCRProviderConfig, true);
	    }

		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 LLMProviderConfig {
	    label: string;
	    baseUrl: string;
	    apiKey: string;
	    model: string;
	    maxTokens: number;
	    temperature: number;
	    timeoutSecs: number;
	    maxInlineBytes: number;

	    static createFrom(source: any = {}) {
	        return new LLMProviderConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.baseUrl = source["baseUrl"];
	        this.apiKey = source["apiKey"];
	        this.model = source["model"];
	        this.maxTokens = source["maxTokens"];
	        this.temperature = source["temperature"];
	        this.timeoutSecs = source["timeoutSecs"];
	        this.maxInlineBytes = source["maxInlineBytes"];
	    }
	}
	export class LLMConfig {
	    activeProvider: string;
	    prompt: string;
	    providers: Record<string, LLMProviderConfig>;

	    static createFrom(source: any = {}) {
	        return new LLMConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.activeProvider = source["activeProvider"];
	        this.prompt = source["prompt"];
	        this.providers = this.convertValues(source["providers"], LLMProviderConfig, true);
	    }

		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 SSHConfig {
	    host: string;
	    port: number;
	    user: string;
	    authMethod: string;
	    password: string;
	    pathPrefix: string;
	    strictHostKey: boolean;
	    knownHostsPath: string;
	    connectTimeoutSecs: number;

	    static createFrom(source: any = {}) {
	        return new SSHConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.host = source["host"];
	        this.port = source["port"];
	        this.user = source["user"];
	        this.authMethod = source["authMethod"];
	        this.password = source["password"];
	        this.pathPrefix = source["pathPrefix"];
	        this.strictHostKey = source["strictHostKey"];
	        this.knownHostsPath = source["knownHostsPath"];
	        this.connectTimeoutSecs = source["connectTimeoutSecs"];
	    }
	}
	export class S3Config {
	    endpoint: string;
	    region: string;
	    bucket: string;
	    accessKeyId: string;
	    secretAccessKey: string;
	    pathPrefix: string;
	    publicUrlBase: string;
	    usePathStyle: boolean;

	    static createFrom(source: any = {}) {
	        return new S3Config(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.endpoint = source["endpoint"];
	        this.region = source["region"];
	        this.bucket = source["bucket"];
	        this.accessKeyId = source["accessKeyId"];
	        this.secretAccessKey = source["secretAccessKey"];
	        this.pathPrefix = source["pathPrefix"];
	        this.publicUrlBase = source["publicUrlBase"];
	        this.usePathStyle = source["usePathStyle"];
	    }
	}
	export class AppConfig {
	    hotkey: string;
	    theme: string;
	    s3: S3Config;
	    ssh: SSHConfig;
	    llm: LLMConfig;
	    ocr: OCRConfig;

	    static createFrom(source: any = {}) {
	        return new AppConfig(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.hotkey = source["hotkey"];
	        this.theme = source["theme"];
	        this.s3 = this.convertValues(source["s3"], S3Config);
	        this.ssh = this.convertValues(source["ssh"], SSHConfig);
	        this.llm = this.convertValues(source["llm"], LLMConfig);
	        this.ocr = this.convertValues(source["ocr"], OCRConfig);
	    }

		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 CaptureActionResult {
	    completed: boolean;
	    path?: string;

	    static createFrom(source: any = {}) {
	        return new CaptureActionResult(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.completed = source["completed"];
	        this.path = source["path"];
	    }
	}
	export class RegionRect {
	    x: number;
	    y: number;
	    w: number;
	    h: number;

	    static createFrom(source: any = {}) {
	        return new RegionRect(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.x = source["x"];
	        this.y = source["y"];
	        this.w = source["w"];
	        this.h = source["h"];
	    }
	}
	export class CaptureResult {
	    rect: RegionRect;
	    annotations: application.Annotation[];

	    static createFrom(source: any = {}) {
	        return new CaptureResult(source);
	    }

	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.rect = this.convertValues(source["rect"], RegionRect);
	        this.annotations = this.convertValues(source["annotations"], application.Annotation);
	    }

		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;
		}
	}

}

