export namespace acom {
	
	export class Status {
	    connected: boolean;
	    port_open: boolean;
	    transport: string;
	    last_error?: string;
	    model?: string;
	    state?: string;
	    operate: boolean;
	    tx: boolean;
	    fwd_w: number;
	    refl_w: number;
	    swr: number;
	    drive_w: number;
	    dc_w: number;
	    temp_c: number;
	    band?: string;
	    fan: number;
	    err_code: number;
	    err_text?: string;
	    nominal_w: number;
	    max_w: number;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.port_open = source["port_open"];
	        this.transport = source["transport"];
	        this.last_error = source["last_error"];
	        this.model = source["model"];
	        this.state = source["state"];
	        this.operate = source["operate"];
	        this.tx = source["tx"];
	        this.fwd_w = source["fwd_w"];
	        this.refl_w = source["refl_w"];
	        this.swr = source["swr"];
	        this.drive_w = source["drive_w"];
	        this.dc_w = source["dc_w"];
	        this.temp_c = source["temp_c"];
	        this.band = source["band"];
	        this.fan = source["fan"];
	        this.err_code = source["err_code"];
	        this.err_text = source["err_text"];
	        this.nominal_w = source["nominal_w"];
	        this.max_w = source["max_w"];
	    }
	}

}

export namespace adif {
	
	export class ExportResult {
	    path: string;
	    count: number;
	    size_kb: number;
	
	    static createFrom(source: any = {}) {
	        return new ExportResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.count = source["count"];
	        this.size_kb = source["size_kb"];
	    }
	}
	export class FieldDef {
	    name: string;
	    kind: string;
	    category: string;
	    promoted: boolean;
	    deprecated: boolean;
	    intl: boolean;
	
	    static createFrom(source: any = {}) {
	        return new FieldDef(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.kind = source["kind"];
	        this.category = source["category"];
	        this.promoted = source["promoted"];
	        this.deprecated = source["deprecated"];
	        this.intl = source["intl"];
	    }
	}
	export class ImportResult {
	    total: number;
	    imported: number;
	    updated: number;
	    skipped: number;
	    duplicates: number;
	    duplicate_samples: string[];
	    errors: string[];
	
	    static createFrom(source: any = {}) {
	        return new ImportResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.imported = source["imported"];
	        this.updated = source["updated"];
	        this.skipped = source["skipped"];
	        this.duplicates = source["duplicates"];
	        this.duplicate_samples = source["duplicate_samples"];
	        this.errors = source["errors"];
	    }
	}

}

export namespace alerts {
	
	export class Rule {
	    id: string;
	    name: string;
	    enabled: boolean;
	    calls?: string[];
	    countries?: string[];
	    continents?: string[];
	    bands?: string[];
	    modes?: string[];
	    spotter_call?: string;
	    spotter_continents?: string[];
	    spotter_countries?: string[];
	    sound: boolean;
	    visual: boolean;
	    email: boolean;
	    again_after_min: number;
	    skip_worked: boolean;
	
	    static createFrom(source: any = {}) {
	        return new Rule(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.enabled = source["enabled"];
	        this.calls = source["calls"];
	        this.countries = source["countries"];
	        this.continents = source["continents"];
	        this.bands = source["bands"];
	        this.modes = source["modes"];
	        this.spotter_call = source["spotter_call"];
	        this.spotter_continents = source["spotter_continents"];
	        this.spotter_countries = source["spotter_countries"];
	        this.sound = source["sound"];
	        this.visual = source["visual"];
	        this.email = source["email"];
	        this.again_after_min = source["again_after_min"];
	        this.skip_worked = source["skip_worked"];
	    }
	}

}

export namespace antgenius {
	
	export class Antenna {
	    index: number;
	    name: string;
	    bands: number;
	
	    static createFrom(source: any = {}) {
	        return new Antenna(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.index = source["index"];
	        this.name = source["name"];
	        this.bands = source["bands"];
	    }
	}
	export class Status {
	    connected: boolean;
	    host?: string;
	    last_error?: string;
	    port_a: number;
	    port_b: number;
	    tx_a: boolean;
	    tx_b: boolean;
	    antennas: Antenna[];
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.host = source["host"];
	        this.last_error = source["last_error"];
	        this.port_a = source["port_a"];
	        this.port_b = source["port_b"];
	        this.tx_a = source["tx_a"];
	        this.tx_b = source["tx_b"];
	        this.antennas = this.convertValues(source["antennas"], Antenna);
	    }
	
		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 audio {
	
	export class Device {
	    id: string;
	    name: string;
	    default: boolean;
	
	    static createFrom(source: any = {}) {
	        return new Device(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.default = source["default"];
	    }
	}

}

export namespace award {
	
	export class BandCount {
	    band: string;
	    worked: number;
	    confirmed: number;
	
	    static createFrom(source: any = {}) {
	        return new BandCount(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.worked = source["worked"];
	        this.confirmed = source["confirmed"];
	    }
	}
	export class OrRule {
	    field: string;
	    match_by?: string;
	    exact_match?: boolean;
	    pattern?: string;
	    leading_str?: string;
	    trailing_str?: string;
	    prefix?: string;
	
	    static createFrom(source: any = {}) {
	        return new OrRule(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.field = source["field"];
	        this.match_by = source["match_by"];
	        this.exact_match = source["exact_match"];
	        this.pattern = source["pattern"];
	        this.leading_str = source["leading_str"];
	        this.trailing_str = source["trailing_str"];
	        this.prefix = source["prefix"];
	    }
	}
	export class Def {
	    code: string;
	    name: string;
	    description?: string;
	    valid: boolean;
	    protected?: boolean;
	    url?: string;
	    download_url?: string;
	    ref_url?: string;
	    valid_from?: string;
	    valid_to?: string;
	    alias?: string;
	    ref_display?: string;
	    type?: string;
	    field: string;
	    match_by?: string;
	    exact_match?: boolean;
	    pattern: string;
	    leading_str?: string;
	    trailing_str?: string;
	    prefix?: string;
	    dynamic?: boolean;
	    one_ref_per_qso?: boolean;
	    or_rules?: OrRule[];
	    dxcc_filter: number[];
	    valid_bands?: string[];
	    valid_modes?: string[];
	    emission?: string[];
	    confirm: string[];
	    validate?: string[];
	    confirm_field?: string;
	    confirm_value?: string;
	    grant_codes?: string;
	    export_credit_granted?: boolean;
	    total: number;
	    builtin: boolean;
	    version?: number;
	    user_edited?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new Def(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.description = source["description"];
	        this.valid = source["valid"];
	        this.protected = source["protected"];
	        this.url = source["url"];
	        this.download_url = source["download_url"];
	        this.ref_url = source["ref_url"];
	        this.valid_from = source["valid_from"];
	        this.valid_to = source["valid_to"];
	        this.alias = source["alias"];
	        this.ref_display = source["ref_display"];
	        this.type = source["type"];
	        this.field = source["field"];
	        this.match_by = source["match_by"];
	        this.exact_match = source["exact_match"];
	        this.pattern = source["pattern"];
	        this.leading_str = source["leading_str"];
	        this.trailing_str = source["trailing_str"];
	        this.prefix = source["prefix"];
	        this.dynamic = source["dynamic"];
	        this.one_ref_per_qso = source["one_ref_per_qso"];
	        this.or_rules = this.convertValues(source["or_rules"], OrRule);
	        this.dxcc_filter = source["dxcc_filter"];
	        this.valid_bands = source["valid_bands"];
	        this.valid_modes = source["valid_modes"];
	        this.emission = source["emission"];
	        this.confirm = source["confirm"];
	        this.validate = source["validate"];
	        this.confirm_field = source["confirm_field"];
	        this.confirm_value = source["confirm_value"];
	        this.grant_codes = source["grant_codes"];
	        this.export_credit_granted = source["export_credit_granted"];
	        this.total = source["total"];
	        this.builtin = source["builtin"];
	        this.version = source["version"];
	        this.user_edited = source["user_edited"];
	    }
	
		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 Rejected {
	    candidate: string;
	    reason: string;
	
	    static createFrom(source: any = {}) {
	        return new Rejected(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.candidate = source["candidate"];
	        this.reason = source["reason"];
	    }
	}
	export class Step {
	    rule: string;
	    field: string;
	    match_by?: string;
	    exact?: boolean;
	    pattern?: string;
	    field_value?: string;
	    candidates?: string[];
	    kept?: string[];
	    rejected?: Rejected[];
	    skipped?: boolean;
	    error?: string;
	
	    static createFrom(source: any = {}) {
	        return new Step(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.rule = source["rule"];
	        this.field = source["field"];
	        this.match_by = source["match_by"];
	        this.exact = source["exact"];
	        this.pattern = source["pattern"];
	        this.field_value = source["field_value"];
	        this.candidates = source["candidates"];
	        this.kept = source["kept"];
	        this.rejected = this.convertValues(source["rejected"], Rejected);
	        this.skipped = source["skipped"];
	        this.error = source["error"];
	    }
	
		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 Explanation {
	    code: string;
	    in_scope: boolean;
	    scope_error?: string;
	    predefined: boolean;
	    ref_count: number;
	    steps: Step[];
	    manual?: string[];
	    superseded?: string[];
	    ambiguous?: string[];
	    result: string[];
	
	    static createFrom(source: any = {}) {
	        return new Explanation(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.in_scope = source["in_scope"];
	        this.scope_error = source["scope_error"];
	        this.predefined = source["predefined"];
	        this.ref_count = source["ref_count"];
	        this.steps = this.convertValues(source["steps"], Step);
	        this.manual = source["manual"];
	        this.superseded = source["superseded"];
	        this.ambiguous = source["ambiguous"];
	        this.result = source["result"];
	    }
	
		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 Ref {
	    ref: string;
	    name?: string;
	    group?: string;
	    subgrp?: string;
	    worked: boolean;
	    confirmed: boolean;
	    validated: boolean;
	    modes: string[];
	    confirmed_modes: string[];
	    bands: string[];
	    confirmed_bands: string[];
	    validated_bands: string[];
	
	    static createFrom(source: any = {}) {
	        return new Ref(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ref = source["ref"];
	        this.name = source["name"];
	        this.group = source["group"];
	        this.subgrp = source["subgrp"];
	        this.worked = source["worked"];
	        this.confirmed = source["confirmed"];
	        this.validated = source["validated"];
	        this.modes = source["modes"];
	        this.confirmed_modes = source["confirmed_modes"];
	        this.bands = source["bands"];
	        this.confirmed_bands = source["confirmed_bands"];
	        this.validated_bands = source["validated_bands"];
	    }
	}
	
	export class Result {
	    code: string;
	    name: string;
	    field: string;
	    worked: number;
	    confirmed: number;
	    validated: number;
	    total: number;
	    bands: BandCount[];
	    refs: Ref[];
	    error?: string;
	
	    static createFrom(source: any = {}) {
	        return new Result(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.field = source["field"];
	        this.worked = source["worked"];
	        this.confirmed = source["confirmed"];
	        this.validated = source["validated"];
	        this.total = source["total"];
	        this.bands = this.convertValues(source["bands"], BandCount);
	        this.refs = this.convertValues(source["refs"], Ref);
	        this.error = source["error"];
	    }
	
		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 awardref {
	
	export class Ref {
	    code: string;
	    name: string;
	    dxcc: number;
	    group: string;
	    subgrp: string;
	    dxcc_list?: number[];
	    pattern?: string;
	    valid: boolean;
	    valid_from?: string;
	    valid_to?: string;
	    score?: number;
	    bonus?: number;
	    gridsquare?: string;
	    alias?: string;
	
	    static createFrom(source: any = {}) {
	        return new Ref(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.dxcc = source["dxcc"];
	        this.group = source["group"];
	        this.subgrp = source["subgrp"];
	        this.dxcc_list = source["dxcc_list"];
	        this.pattern = source["pattern"];
	        this.valid = source["valid"];
	        this.valid_from = source["valid_from"];
	        this.valid_to = source["valid_to"];
	        this.score = source["score"];
	        this.bonus = source["bonus"];
	        this.gridsquare = source["gridsquare"];
	        this.alias = source["alias"];
	    }
	}
	export class Preset {
	    key: string;
	    name: string;
	    field: string;
	    dxcc: number;
	    refs: Ref[];
	
	    static createFrom(source: any = {}) {
	        return new Preset(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.key = source["key"];
	        this.name = source["name"];
	        this.field = source["field"];
	        this.dxcc = source["dxcc"];
	        this.refs = this.convertValues(source["refs"], Ref);
	    }
	
		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 bandopen {
	
	export class Opening {
	    band: string;
	    calls: number;
	    median_km: number;
	    bearing_min: number;
	    bearing_max: number;
	    compass: string;
	    in_season: boolean;
	    // Go type: time
	    at: any;
	    examples: string[];
	
	    static createFrom(source: any = {}) {
	        return new Opening(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.calls = source["calls"];
	        this.median_km = source["median_km"];
	        this.bearing_min = source["bearing_min"];
	        this.bearing_max = source["bearing_max"];
	        this.compass = source["compass"];
	        this.in_season = source["in_season"];
	        this.at = this.convertValues(source["at"], null);
	        this.examples = source["examples"];
	    }
	
		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 cat {
	
	export class FlexMeter {
	    id: number;
	    src?: string;
	    name?: string;
	    unit?: string;
	    slice: number;
	    value: number;
	    lo: number;
	    hi: number;
	
	    static createFrom(source: any = {}) {
	        return new FlexMeter(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.src = source["src"];
	        this.name = source["name"];
	        this.unit = source["unit"];
	        this.slice = source["slice"];
	        this.value = source["value"];
	        this.lo = source["lo"];
	        this.hi = source["hi"];
	    }
	}
	export class FlexRadio {
	    ip: string;
	    port: number;
	    model: string;
	    nickname: string;
	    serial: string;
	    callsign: string;
	
	    static createFrom(source: any = {}) {
	        return new FlexRadio(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ip = source["ip"];
	        this.port = source["port"];
	        this.model = source["model"];
	        this.nickname = source["nickname"];
	        this.serial = source["serial"];
	        this.callsign = source["callsign"];
	    }
	}
	export class FlexSliceInfo {
	    index: number;
	    letter: string;
	    freq_hz: number;
	    mode?: string;
	    band?: string;
	    active: boolean;
	    tx: boolean;
	
	    static createFrom(source: any = {}) {
	        return new FlexSliceInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.index = source["index"];
	        this.letter = source["letter"];
	        this.freq_hz = source["freq_hz"];
	        this.mode = source["mode"];
	        this.band = source["band"];
	        this.active = source["active"];
	        this.tx = source["tx"];
	    }
	}
	export class FlexTXState {
	    available: boolean;
	    model?: string;
	    slices?: FlexSliceInfo[];
	    rf_power: number;
	    tune_power: number;
	    tune: boolean;
	    transmitting: boolean;
	    vox_enable: boolean;
	    vox_level: number;
	    vox_delay: number;
	    proc_enable: boolean;
	    proc_level: number;
	    mon: boolean;
	    mon_level: number;
	    mic_level: number;
	    tx_filter_low: number;
	    tx_filter_high: number;
	    mic_profile?: string;
	    mic_profiles?: string[];
	    atu_status?: string;
	    atu_memories: boolean;
	    rx_avail: boolean;
	    split: boolean;
	    rx_freq_hz?: number;
	    tx_freq_hz?: number;
	    agc_mode?: string;
	    agc_threshold: number;
	    audio_level: number;
	    mute: boolean;
	    rx_ant?: string;
	    tx_ant?: string;
	    ant_list?: string[];
	    tx_ant_list?: string[];
	    nb: boolean;
	    nb_level: number;
	    nr: boolean;
	    nr_level: number;
	    anf: boolean;
	    anf_level: number;
	    wnb: boolean;
	    wnb_level: number;
	    lms_nr: boolean;
	    lms_nr_level: number;
	    lms_anf: boolean;
	    lms_anf_level: number;
	    speex_nr: boolean;
	    speex_nr_level: number;
	    rnn: boolean;
	    anft: boolean;
	    nrf: boolean;
	    nrf_level: number;
	    dsp_v4: boolean;
	    dax_ch: number;
	    tx_dax: boolean;
	    rit: boolean;
	    rit_freq: number;
	    xit: boolean;
	    xit_freq: number;
	    mode?: string;
	    cw_speed: number;
	    cw_pitch: number;
	    cw_break_in_delay: number;
	    cw_sidetone: boolean;
	    cw_mon_level: number;
	    apf: boolean;
	    apf_level: number;
	    filter_lo: number;
	    filter_hi: number;
	    amp_available: boolean;
	    amp_model?: string;
	    amp_operate: boolean;
	    amp_fault?: string;
	    meters?: FlexMeter[];
	
	    static createFrom(source: any = {}) {
	        return new FlexTXState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.model = source["model"];
	        this.slices = this.convertValues(source["slices"], FlexSliceInfo);
	        this.rf_power = source["rf_power"];
	        this.tune_power = source["tune_power"];
	        this.tune = source["tune"];
	        this.transmitting = source["transmitting"];
	        this.vox_enable = source["vox_enable"];
	        this.vox_level = source["vox_level"];
	        this.vox_delay = source["vox_delay"];
	        this.proc_enable = source["proc_enable"];
	        this.proc_level = source["proc_level"];
	        this.mon = source["mon"];
	        this.mon_level = source["mon_level"];
	        this.mic_level = source["mic_level"];
	        this.tx_filter_low = source["tx_filter_low"];
	        this.tx_filter_high = source["tx_filter_high"];
	        this.mic_profile = source["mic_profile"];
	        this.mic_profiles = source["mic_profiles"];
	        this.atu_status = source["atu_status"];
	        this.atu_memories = source["atu_memories"];
	        this.rx_avail = source["rx_avail"];
	        this.split = source["split"];
	        this.rx_freq_hz = source["rx_freq_hz"];
	        this.tx_freq_hz = source["tx_freq_hz"];
	        this.agc_mode = source["agc_mode"];
	        this.agc_threshold = source["agc_threshold"];
	        this.audio_level = source["audio_level"];
	        this.mute = source["mute"];
	        this.rx_ant = source["rx_ant"];
	        this.tx_ant = source["tx_ant"];
	        this.ant_list = source["ant_list"];
	        this.tx_ant_list = source["tx_ant_list"];
	        this.nb = source["nb"];
	        this.nb_level = source["nb_level"];
	        this.nr = source["nr"];
	        this.nr_level = source["nr_level"];
	        this.anf = source["anf"];
	        this.anf_level = source["anf_level"];
	        this.wnb = source["wnb"];
	        this.wnb_level = source["wnb_level"];
	        this.lms_nr = source["lms_nr"];
	        this.lms_nr_level = source["lms_nr_level"];
	        this.lms_anf = source["lms_anf"];
	        this.lms_anf_level = source["lms_anf_level"];
	        this.speex_nr = source["speex_nr"];
	        this.speex_nr_level = source["speex_nr_level"];
	        this.rnn = source["rnn"];
	        this.anft = source["anft"];
	        this.nrf = source["nrf"];
	        this.nrf_level = source["nrf_level"];
	        this.dsp_v4 = source["dsp_v4"];
	        this.dax_ch = source["dax_ch"];
	        this.tx_dax = source["tx_dax"];
	        this.rit = source["rit"];
	        this.rit_freq = source["rit_freq"];
	        this.xit = source["xit"];
	        this.xit_freq = source["xit_freq"];
	        this.mode = source["mode"];
	        this.cw_speed = source["cw_speed"];
	        this.cw_pitch = source["cw_pitch"];
	        this.cw_break_in_delay = source["cw_break_in_delay"];
	        this.cw_sidetone = source["cw_sidetone"];
	        this.cw_mon_level = source["cw_mon_level"];
	        this.apf = source["apf"];
	        this.apf_level = source["apf_level"];
	        this.filter_lo = source["filter_lo"];
	        this.filter_hi = source["filter_hi"];
	        this.amp_available = source["amp_available"];
	        this.amp_model = source["amp_model"];
	        this.amp_operate = source["amp_operate"];
	        this.amp_fault = source["amp_fault"];
	        this.meters = this.convertValues(source["meters"], FlexMeter);
	    }
	
		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 IcomTXState {
	    available: boolean;
	    model?: string;
	    mode?: string;
	    transmitting: boolean;
	    split: boolean;
	    sub_hz: number;
	    s_meter: number;
	    power_meter: number;
	    swr_meter: number;
	    rit_hz: number;
	    rit_on: boolean;
	    xit_on: boolean;
	    key_speed_wpm: number;
	    break_in: number;
	    rf_power: number;
	    mic_gain: number;
	    af_gain: number;
	    rf_gain: number;
	    nb: boolean;
	    nb_level: number;
	    nr: boolean;
	    nr_level: number;
	    anf: boolean;
	    apf: boolean;
	    agc?: string;
	    preamp: number;
	    att: number;
	    filter: number;
	    antenna: number;
	    atu_on: boolean;
	    pbt_inner: number;
	    pbt_outer: number;
	    manual_notch: boolean;
	    notch_pos: number;
	    squelch: number;
	    comp: boolean;
	    comp_level: number;
	    monitor: boolean;
	    mon_level: number;
	    vox: boolean;
	    vox_gain: number;
	    anti_vox: number;
	
	    static createFrom(source: any = {}) {
	        return new IcomTXState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.model = source["model"];
	        this.mode = source["mode"];
	        this.transmitting = source["transmitting"];
	        this.split = source["split"];
	        this.sub_hz = source["sub_hz"];
	        this.s_meter = source["s_meter"];
	        this.power_meter = source["power_meter"];
	        this.swr_meter = source["swr_meter"];
	        this.rit_hz = source["rit_hz"];
	        this.rit_on = source["rit_on"];
	        this.xit_on = source["xit_on"];
	        this.key_speed_wpm = source["key_speed_wpm"];
	        this.break_in = source["break_in"];
	        this.rf_power = source["rf_power"];
	        this.mic_gain = source["mic_gain"];
	        this.af_gain = source["af_gain"];
	        this.rf_gain = source["rf_gain"];
	        this.nb = source["nb"];
	        this.nb_level = source["nb_level"];
	        this.nr = source["nr"];
	        this.nr_level = source["nr_level"];
	        this.anf = source["anf"];
	        this.apf = source["apf"];
	        this.agc = source["agc"];
	        this.preamp = source["preamp"];
	        this.att = source["att"];
	        this.filter = source["filter"];
	        this.antenna = source["antenna"];
	        this.atu_on = source["atu_on"];
	        this.pbt_inner = source["pbt_inner"];
	        this.pbt_outer = source["pbt_outer"];
	        this.manual_notch = source["manual_notch"];
	        this.notch_pos = source["notch_pos"];
	        this.squelch = source["squelch"];
	        this.comp = source["comp"];
	        this.comp_level = source["comp_level"];
	        this.monitor = source["monitor"];
	        this.mon_level = source["mon_level"];
	        this.vox = source["vox"];
	        this.vox_gain = source["vox_gain"];
	        this.anti_vox = source["anti_vox"];
	    }
	}
	export class KenwoodTXState {
	    available: boolean;
	    model?: string;
	    elecraft: boolean;
	    mode?: string;
	    data_sub?: string;
	    transmitting: boolean;
	    split: boolean;
	    split_tx_hz: number;
	    s_meter: number;
	    s_meter_raw: number;
	    power_meter: number;
	    power_w: number;
	    swr: number;
	    swr_raw: number;
	    rf_power: number;
	    af_gain: number;
	    rf_gain: number;
	    mic_gain: number;
	    squelch: number;
	    preamp: boolean;
	    att: boolean;
	    nb: boolean;
	    nr: boolean;
	    agc?: string;
	    filter_hz: number;
	    antenna: number;
	    rit: boolean;
	    xit: boolean;
	    rit_offset: number;
	    key_speed: number;
	    meters_provisional: boolean;
	
	    static createFrom(source: any = {}) {
	        return new KenwoodTXState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.model = source["model"];
	        this.elecraft = source["elecraft"];
	        this.mode = source["mode"];
	        this.data_sub = source["data_sub"];
	        this.transmitting = source["transmitting"];
	        this.split = source["split"];
	        this.split_tx_hz = source["split_tx_hz"];
	        this.s_meter = source["s_meter"];
	        this.s_meter_raw = source["s_meter_raw"];
	        this.power_meter = source["power_meter"];
	        this.power_w = source["power_w"];
	        this.swr = source["swr"];
	        this.swr_raw = source["swr_raw"];
	        this.rf_power = source["rf_power"];
	        this.af_gain = source["af_gain"];
	        this.rf_gain = source["rf_gain"];
	        this.mic_gain = source["mic_gain"];
	        this.squelch = source["squelch"];
	        this.preamp = source["preamp"];
	        this.att = source["att"];
	        this.nb = source["nb"];
	        this.nr = source["nr"];
	        this.agc = source["agc"];
	        this.filter_hz = source["filter_hz"];
	        this.antenna = source["antenna"];
	        this.rit = source["rit"];
	        this.xit = source["xit"];
	        this.rit_offset = source["rit_offset"];
	        this.key_speed = source["key_speed"];
	        this.meters_provisional = source["meters_provisional"];
	    }
	}
	export class RigState {
	    enabled: boolean;
	    connected: boolean;
	    backend?: string;
	    rig_num?: number;
	    rig?: string;
	    freq_hz?: number;
	    freq_rx_hz?: number;
	    split?: boolean;
	    mode?: string;
	    band?: string;
	    vfo?: string;
	    error?: string;
	    // Go type: time
	    updated_at?: any;
	
	    static createFrom(source: any = {}) {
	        return new RigState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.connected = source["connected"];
	        this.backend = source["backend"];
	        this.rig_num = source["rig_num"];
	        this.rig = source["rig"];
	        this.freq_hz = source["freq_hz"];
	        this.freq_rx_hz = source["freq_rx_hz"];
	        this.split = source["split"];
	        this.mode = source["mode"];
	        this.band = source["band"];
	        this.vfo = source["vfo"];
	        this.error = source["error"];
	        this.updated_at = this.convertValues(source["updated_at"], null);
	    }
	
		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 ScopeSweep {
	    amp: number[];
	    seq: number;
	    low_hz: number;
	    high_hz: number;
	    fixed: boolean;
	    unsupported: boolean;
	
	    static createFrom(source: any = {}) {
	        return new ScopeSweep(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.amp = source["amp"];
	        this.seq = source["seq"];
	        this.low_hz = source["low_hz"];
	        this.high_hz = source["high_hz"];
	        this.fixed = source["fixed"];
	        this.unsupported = source["unsupported"];
	    }
	}
	export class TCIPanelState {
	    connected: boolean;
	    device?: string;
	    protocol?: string;
	    drive: number;
	    tune_drive: number;
	    mic_level: number;
	    tx_enabled: boolean;
	    tx: boolean;
	    tuning: boolean;
	    volume: number;
	    mute: boolean;
	    agc?: string;
	    squelch_on: boolean;
	    squelch: number;
	    nb: boolean;
	    nr: boolean;
	    anf: boolean;
	    apf: boolean;
	    filter_lo: number;
	    filter_hi: number;
	    rit: boolean;
	    rit_offset: number;
	    xit: boolean;
	    xit_offset: number;
	    lock: boolean;
	    split: boolean;
	    smeter: number;
	    tx_power_w: number;
	    tx_swr: number;
	    modulations?: string[];
	
	    static createFrom(source: any = {}) {
	        return new TCIPanelState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.device = source["device"];
	        this.protocol = source["protocol"];
	        this.drive = source["drive"];
	        this.tune_drive = source["tune_drive"];
	        this.mic_level = source["mic_level"];
	        this.tx_enabled = source["tx_enabled"];
	        this.tx = source["tx"];
	        this.tuning = source["tuning"];
	        this.volume = source["volume"];
	        this.mute = source["mute"];
	        this.agc = source["agc"];
	        this.squelch_on = source["squelch_on"];
	        this.squelch = source["squelch"];
	        this.nb = source["nb"];
	        this.nr = source["nr"];
	        this.anf = source["anf"];
	        this.apf = source["apf"];
	        this.filter_lo = source["filter_lo"];
	        this.filter_hi = source["filter_hi"];
	        this.rit = source["rit"];
	        this.rit_offset = source["rit_offset"];
	        this.xit = source["xit"];
	        this.xit_offset = source["xit_offset"];
	        this.lock = source["lock"];
	        this.split = source["split"];
	        this.smeter = source["smeter"];
	        this.tx_power_w = source["tx_power_w"];
	        this.tx_swr = source["tx_swr"];
	        this.modulations = source["modulations"];
	    }
	}
	export class YaesuTXState {
	    available: boolean;
	    model?: string;
	    mode?: string;
	    raw_mode?: string;
	    transmitting: boolean;
	    split: boolean;
	    split_tx_hz: number;
	    s_meter: number;
	    power_meter: number;
	    swr_meter: number;
	    rf_power: number;
	    max_power: number;
	    narrow_supported: boolean;
	    mic_gain: number;
	    af_gain: number;
	    rf_gain: number;
	    squelch: number;
	    agc?: string;
	    preamp: number;
	    antenna: number;
	    att: number;
	    nb: boolean;
	    nr: boolean;
	    nr_level: number;
	    narrow: boolean;
	    swr: number;
	    power_w: number;
	    vox: boolean;
	    key_speed: number;
	    break_in: boolean;
	
	    static createFrom(source: any = {}) {
	        return new YaesuTXState(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.available = source["available"];
	        this.model = source["model"];
	        this.mode = source["mode"];
	        this.raw_mode = source["raw_mode"];
	        this.transmitting = source["transmitting"];
	        this.split = source["split"];
	        this.split_tx_hz = source["split_tx_hz"];
	        this.s_meter = source["s_meter"];
	        this.power_meter = source["power_meter"];
	        this.swr_meter = source["swr_meter"];
	        this.rf_power = source["rf_power"];
	        this.max_power = source["max_power"];
	        this.narrow_supported = source["narrow_supported"];
	        this.mic_gain = source["mic_gain"];
	        this.af_gain = source["af_gain"];
	        this.rf_gain = source["rf_gain"];
	        this.squelch = source["squelch"];
	        this.agc = source["agc"];
	        this.preamp = source["preamp"];
	        this.antenna = source["antenna"];
	        this.att = source["att"];
	        this.nb = source["nb"];
	        this.nr = source["nr"];
	        this.nr_level = source["nr_level"];
	        this.narrow = source["narrow"];
	        this.swr = source["swr"];
	        this.power_w = source["power_w"];
	        this.vox = source["vox"];
	        this.key_speed = source["key_speed"];
	        this.break_in = source["break_in"];
	    }
	}

}

export namespace cluster {
	
	export class ServerConfig {
	    id: number;
	    name: string;
	    host: string;
	    port: number;
	    login_override: string;
	    password?: string;
	    init_commands: string;
	    enabled: boolean;
	    sort_order: number;
	
	    static createFrom(source: any = {}) {
	        return new ServerConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.login_override = source["login_override"];
	        this.password = source["password"];
	        this.init_commands = source["init_commands"];
	        this.enabled = source["enabled"];
	        this.sort_order = source["sort_order"];
	    }
	}
	export class ServerStatus {
	    server_id: number;
	    name: string;
	    host: string;
	    port: number;
	    state: string;
	    login?: string;
	    error?: string;
	    // Go type: time
	    connected_at?: any;
	    spots_count?: number;
	    retries?: number;
	
	    static createFrom(source: any = {}) {
	        return new ServerStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.server_id = source["server_id"];
	        this.name = source["name"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.state = source["state"];
	        this.login = source["login"];
	        this.error = source["error"];
	        this.connected_at = this.convertValues(source["connected_at"], null);
	        this.spots_count = source["spots_count"];
	        this.retries = source["retries"];
	    }
	
		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 contest {
	
	export class Def {
	    code: string;
	    name: string;
	    exchange: string;
	
	    static createFrom(source: any = {}) {
	        return new Def(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.exchange = source["exchange"];
	    }
	}

}

export namespace dxped {
	
	export class News {
	    title: string;
	    link: string;
	    pub_date: string;
	    excerpt: string;
	    creator: string;
	    image_url: string;
	    tag: string;
	    calls: string[];
	
	    static createFrom(source: any = {}) {
	        return new News(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.title = source["title"];
	        this.link = source["link"];
	        this.pub_date = source["pub_date"];
	        this.excerpt = source["excerpt"];
	        this.creator = source["creator"];
	        this.image_url = source["image_url"];
	        this.tag = source["tag"];
	        this.calls = source["calls"];
	    }
	}

}

export namespace extsvc {
	
	export class ServiceConfig {
	    api_key: string;
	    url: string;
	    station_id: string;
	    email: string;
	    username: string;
	    password: string;
	    callsign: string;
	    code: string;
	    qth_nickname: string;
	    force_station_callsign: string;
	    tqsl_path: string;
	    station_location: string;
	    key_password: string;
	    upload_flags: string[];
	    write_log: boolean;
	    auto_upload: boolean;
	    on_air: boolean;
	    upload_mode: string;
	
	    static createFrom(source: any = {}) {
	        return new ServiceConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.api_key = source["api_key"];
	        this.url = source["url"];
	        this.station_id = source["station_id"];
	        this.email = source["email"];
	        this.username = source["username"];
	        this.password = source["password"];
	        this.callsign = source["callsign"];
	        this.code = source["code"];
	        this.qth_nickname = source["qth_nickname"];
	        this.force_station_callsign = source["force_station_callsign"];
	        this.tqsl_path = source["tqsl_path"];
	        this.station_location = source["station_location"];
	        this.key_password = source["key_password"];
	        this.upload_flags = source["upload_flags"];
	        this.write_log = source["write_log"];
	        this.auto_upload = source["auto_upload"];
	        this.on_air = source["on_air"];
	        this.upload_mode = source["upload_mode"];
	    }
	}
	export class ExternalServices {
	    qrz: ServiceConfig;
	    clublog: ServiceConfig;
	    lotw: ServiceConfig;
	    hrdlog: ServiceConfig;
	    eqsl: ServiceConfig;
	    cloudlog: ServiceConfig;
	    hamlog: ServiceConfig;
	    hamqth: ServiceConfig;
	    delete_remote: boolean;
	
	    static createFrom(source: any = {}) {
	        return new ExternalServices(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qrz = this.convertValues(source["qrz"], ServiceConfig);
	        this.clublog = this.convertValues(source["clublog"], ServiceConfig);
	        this.lotw = this.convertValues(source["lotw"], ServiceConfig);
	        this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
	        this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
	        this.cloudlog = this.convertValues(source["cloudlog"], ServiceConfig);
	        this.hamlog = this.convertValues(source["hamlog"], ServiceConfig);
	        this.hamqth = this.convertValues(source["hamqth"], ServiceConfig);
	        this.delete_remote = source["delete_remote"];
	    }
	
		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 StationLocation {
	    name: string;
	    call: string;
	    grid: string;
	    dxcc: number;
	
	    static createFrom(source: any = {}) {
	        return new StationLocation(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.call = source["call"];
	        this.grid = source["grid"];
	        this.dxcc = source["dxcc"];
	    }
	}

}

export namespace kpa {
	
	export class Status {
	    connected: boolean;
	    transport: string;
	    model?: string;
	    last_error?: string;
	    power_on: boolean;
	    operate: boolean;
	    fwd_w: number;
	    swr: number;
	    volt_v: number;
	    cur_a: number;
	    temp_c: number;
	    band?: string;
	    tuning: boolean;
	    fault_code: number;
	    fault_text?: string;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.transport = source["transport"];
	        this.model = source["model"];
	        this.last_error = source["last_error"];
	        this.power_on = source["power_on"];
	        this.operate = source["operate"];
	        this.fwd_w = source["fwd_w"];
	        this.swr = source["swr"];
	        this.volt_v = source["volt_v"];
	        this.cur_a = source["cur_a"];
	        this.temp_c = source["temp_c"];
	        this.band = source["band"];
	        this.tuning = source["tuning"];
	        this.fault_code = source["fault_code"];
	        this.fault_text = source["fault_text"];
	    }
	}

}

export namespace lookup {
	
	export class Result {
	    callsign: string;
	    name?: string;
	    qth?: string;
	    address?: string;
	    state?: string;
	    cnty?: string;
	    country?: string;
	    grid?: string;
	    lat?: number;
	    lon?: number;
	    dxcc?: number;
	    cqz?: number;
	    ituz?: number;
	    cont?: string;
	    email?: string;
	    qsl_via?: string;
	    web?: string;
	    iota?: string;
	    rda?: string;
	    zip?: string;
	    image_url?: string;
	    source: string;
	    // Go type: time
	    fetched_at: any;
	
	    static createFrom(source: any = {}) {
	        return new Result(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.name = source["name"];
	        this.qth = source["qth"];
	        this.address = source["address"];
	        this.state = source["state"];
	        this.cnty = source["cnty"];
	        this.country = source["country"];
	        this.grid = source["grid"];
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	        this.dxcc = source["dxcc"];
	        this.cqz = source["cqz"];
	        this.ituz = source["ituz"];
	        this.cont = source["cont"];
	        this.email = source["email"];
	        this.qsl_via = source["qsl_via"];
	        this.web = source["web"];
	        this.iota = source["iota"];
	        this.rda = source["rda"];
	        this.zip = source["zip"];
	        this.image_url = source["image_url"];
	        this.source = source["source"];
	        this.fetched_at = this.convertValues(source["fetched_at"], null);
	    }
	
		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 lotwusers {
	
	export class Info {
	    is_user: boolean;
	    last_upload?: string;
	    days_ago: number;
	    feed_date?: string;
	    feed_stale: boolean;
	
	    static createFrom(source: any = {}) {
	        return new Info(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.is_user = source["is_user"];
	        this.last_upload = source["last_upload"];
	        this.days_ago = source["days_ago"];
	        this.feed_date = source["feed_date"];
	        this.feed_stale = source["feed_stale"];
	    }
	}

}

export namespace main {
	
	export class ADIFWatchFile {
	    path: string;
	    enabled: boolean;
	    offset: number;
	
	    static createFrom(source: any = {}) {
	        return new ADIFWatchFile(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.enabled = source["enabled"];
	        this.offset = source["offset"];
	    }
	}
	export class ADIFMonitorConfig {
	    enabled: boolean;
	    files: ADIFWatchFile[];
	
	    static createFrom(source: any = {}) {
	        return new ADIFMonitorConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.files = this.convertValues(source["files"], ADIFWatchFile);
	    }
	
		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 AmpConfig {
	    id: string;
	    name: string;
	    enabled: boolean;
	    type: string;
	    transport: string;
	    host: string;
	    port: number;
	    password: string;
	    com_port: string;
	    baud: number;
	    freq_out: boolean;
	    freq_com_port: string;
	    freq_baud: number;
	    freq_broadcast_ms: number;
	
	    static createFrom(source: any = {}) {
	        return new AmpConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.enabled = source["enabled"];
	        this.type = source["type"];
	        this.transport = source["transport"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.password = source["password"];
	        this.com_port = source["com_port"];
	        this.baud = source["baud"];
	        this.freq_out = source["freq_out"];
	        this.freq_com_port = source["freq_com_port"];
	        this.freq_baud = source["freq_baud"];
	        this.freq_broadcast_ms = source["freq_broadcast_ms"];
	    }
	}
	export class AmpStatus {
	    id: string;
	    name: string;
	    type: string;
	    pgxl?: powergenius.Status;
	    spe?: spe.Status;
	    acom?: acom.Status;
	    kpa?: kpa.Status;
	
	    static createFrom(source: any = {}) {
	        return new AmpStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.type = source["type"];
	        this.pgxl = this.convertValues(source["pgxl"], powergenius.Status);
	        this.spe = this.convertValues(source["spe"], spe.Status);
	        this.acom = this.convertValues(source["acom"], acom.Status);
	        this.kpa = this.convertValues(source["kpa"], kpa.Status);
	    }
	
		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 AntGeniusSettings {
	    enabled: boolean;
	    host: string;
	    password: string;
	    use_for_my_antenna: boolean;
	    ant1_port: number;
	
	    static createFrom(source: any = {}) {
	        return new AntGeniusSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.host = source["host"];
	        this.password = source["password"];
	        this.use_for_my_antenna = source["use_for_my_antenna"];
	        this.ant1_port = source["ant1_port"];
	    }
	}
	export class AudioSettings {
	    from_radio: string;
	    to_radio: string;
	    recording_device: string;
	    listening_device: string;
	    qso_record: boolean;
	    qso_dir: string;
	    preroll_seconds: number;
	    ptt_method: string;
	    ptt_port: string;
	    ptt_data: boolean;
	    format: string;
	    from_gain: number;
	    mic_gain: number;
	    tx_gain: number;
	    qso_play_gain: number;
	
	    static createFrom(source: any = {}) {
	        return new AudioSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.from_radio = source["from_radio"];
	        this.to_radio = source["to_radio"];
	        this.recording_device = source["recording_device"];
	        this.listening_device = source["listening_device"];
	        this.qso_record = source["qso_record"];
	        this.qso_dir = source["qso_dir"];
	        this.preroll_seconds = source["preroll_seconds"];
	        this.ptt_method = source["ptt_method"];
	        this.ptt_port = source["ptt_port"];
	        this.ptt_data = source["ptt_data"];
	        this.format = source["format"];
	        this.from_gain = source["from_gain"];
	        this.mic_gain = source["mic_gain"];
	        this.tx_gain = source["tx_gain"];
	        this.qso_play_gain = source["qso_play_gain"];
	    }
	}
	export class AutoCallSettings {
	    enabled: boolean;
	    only: string;
	    attempts: number;
	    watched_attempts: number;
	    misses: number;
	    max_rounds: number;
	    rest_periods: number;
	    on_screen_only: boolean;
	    trace: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AutoCallSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.only = source["only"];
	        this.attempts = source["attempts"];
	        this.watched_attempts = source["watched_attempts"];
	        this.misses = source["misses"];
	        this.max_rounds = source["max_rounds"];
	        this.rest_periods = source["rest_periods"];
	        this.on_screen_only = source["on_screen_only"];
	        this.trace = source["trace"];
	    }
	}
	export class AutoCallStatus {
	    enabled: boolean;
	    only: string;
	    target: string;
	    waiting: string;
	    calls: number;
	    max: number;
	    misses: number;
	    max_miss: number;
	    stopped: boolean;
	    greylisted: number;
	    reason: string;
	
	    static createFrom(source: any = {}) {
	        return new AutoCallStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.only = source["only"];
	        this.target = source["target"];
	        this.waiting = source["waiting"];
	        this.calls = source["calls"];
	        this.max = source["max"];
	        this.misses = source["misses"];
	        this.max_miss = source["max_miss"];
	        this.stopped = source["stopped"];
	        this.greylisted = source["greylisted"];
	        this.reason = source["reason"];
	    }
	}
	export class AutostartLaunchResult {
	    id: string;
	    name: string;
	    status: string;
	    message: string;
	
	    static createFrom(source: any = {}) {
	        return new AutostartLaunchResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.status = source["status"];
	        this.message = source["message"];
	    }
	}
	export class AutostartProgram {
	    id: string;
	    name: string;
	    path: string;
	    args: string;
	    enabled: boolean;
	    close_on_exit?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AutostartProgram(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.args = source["args"];
	        this.enabled = source["enabled"];
	        this.close_on_exit = source["close_on_exit"];
	    }
	}
	export class AwardExplain {
	    qso: qso.QSO;
	    explanation: award.Explanation;
	
	    static createFrom(source: any = {}) {
	        return new AwardExplain(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qso = this.convertValues(source["qso"], qso.QSO);
	        this.explanation = this.convertValues(source["explanation"], award.Explanation);
	    }
	
		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 AwardImportPreviewEntry {
	    code: string;
	    name: string;
	    references: number;
	    exists: boolean;
	    mine_name: string;
	    mine_refs: number;
	    protected: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AwardImportPreviewEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.references = source["references"];
	        this.exists = source["exists"];
	        this.mine_name = source["mine_name"];
	        this.mine_refs = source["mine_refs"];
	        this.protected = source["protected"];
	    }
	}
	export class AwardImportPreview {
	    path: string;
	    awards: AwardImportPreviewEntry[];
	
	    static createFrom(source: any = {}) {
	        return new AwardImportPreview(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.awards = this.convertValues(source["awards"], AwardImportPreviewEntry);
	    }
	
		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 AwardImportResult {
	    awards: number;
	    references: number;
	
	    static createFrom(source: any = {}) {
	        return new AwardImportResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.awards = source["awards"];
	        this.references = source["references"];
	    }
	}
	export class AwardRefMeta {
	    code: string;
	    count: number;
	    updated_at: string;
	    can_update: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AwardRefMeta(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.count = source["count"];
	        this.updated_at = source["updated_at"];
	        this.can_update = source["can_update"];
	    }
	}
	export class AwardRefNewResult {
	    new: Record<string, boolean>;
	    pending: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AwardRefNewResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.new = source["new"];
	        this.pending = source["pending"];
	    }
	}
	export class AwardStatRow {
	    label: string;
	    cells: number[];
	    total: number;
	    grand_total: number;
	
	    static createFrom(source: any = {}) {
	        return new AwardStatRow(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.cells = source["cells"];
	        this.total = source["total"];
	        this.grand_total = source["grand_total"];
	    }
	}
	export class AwardStatsResult {
	    code: string;
	    bands: string[];
	    rows: AwardStatRow[];
	
	    static createFrom(source: any = {}) {
	        return new AwardStatsResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.bands = source["bands"];
	        this.rows = this.convertValues(source["rows"], AwardStatRow);
	    }
	
		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 AwardUpdate {
	    code: string;
	    name: string;
	    from: number;
	    to: number;
	
	    static createFrom(source: any = {}) {
	        return new AwardUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.name = source["name"];
	        this.from = source["from"];
	        this.to = source["to"];
	    }
	}
	export class BackfillDistancesResult {
	    scanned: number;
	    filled: number;
	    no_grid: number;
	
	    static createFrom(source: any = {}) {
	        return new BackfillDistancesResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.scanned = source["scanned"];
	        this.filled = source["filled"];
	        this.no_grid = source["no_grid"];
	    }
	}
	export class BackfillRDAResult {
	    scanned: number;
	    dated: number;
	    current: number;
	    unknown: number;
	    skipped: number;
	
	    static createFrom(source: any = {}) {
	        return new BackfillRDAResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.scanned = source["scanned"];
	        this.dated = source["dated"];
	        this.current = source["current"];
	        this.unknown = source["unknown"];
	        this.skipped = source["skipped"];
	    }
	}
	export class BackfillUSCountiesResult {
	    scanned: number;
	    county: number;
	    grid: number;
	
	    static createFrom(source: any = {}) {
	        return new BackfillUSCountiesResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.scanned = source["scanned"];
	        this.county = source["county"];
	        this.grid = source["grid"];
	    }
	}
	export class BackupSettings {
	    enabled: boolean;
	    folder: string;
	    rotation: number;
	    zip: boolean;
	    every_exit: boolean;
	    keep_all: boolean;
	    last_backup_at: string;
	    default_folder: string;
	
	    static createFrom(source: any = {}) {
	        return new BackupSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.folder = source["folder"];
	        this.rotation = source["rotation"];
	        this.zip = source["zip"];
	        this.every_exit = source["every_exit"];
	        this.keep_all = source["keep_all"];
	        this.last_backup_at = source["last_backup_at"];
	        this.default_folder = source["default_folder"];
	    }
	}
	export class BandOpenSettings {
	    enabled: boolean;
	    bands: string[];
	    available: string[];
	    near_km: number;
	
	    static createFrom(source: any = {}) {
	        return new BandOpenSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.bands = source["bands"];
	        this.available = source["available"];
	        this.near_km = source["near_km"];
	    }
	}
	export class CATSettings {
	    enabled: boolean;
	    backend: string;
	    omnirig_rig: number;
	    omnirig_vfo: string;
	    digi_as_usb: boolean;
	    flex_host: string;
	    flex_port: number;
	    flex_spots: boolean;
	    flex_dvk_dax: boolean;
	    flex_decode_spots: boolean;
	    flex_decode_secs: number;
	    xiegu_port: string;
	    xiegu_baud: number;
	    xiegu_addr: number;
	    xiegu_ptt_line: string;
	    yaesu_port: string;
	    yaesu_baud: number;
	    kenwood_host: string;
	    kenwood_port: string;
	    kenwood_link: string;
	    kenwood_baud: number;
	    kenwood_data_mode: string;
	    yaesu_low_lines: boolean;
	    yaesu_rtty_usb: boolean;
	    kenwood_low_lines: boolean;
	    icom_port: string;
	    icom_baud: number;
	    icom_addr: number;
	    icom_net_host: string;
	    icom_net_user: string;
	    icom_net_pass: string;
	    icom_net_audio: boolean;
	    tci_host: string;
	    tci_port: number;
	    tci_spots: boolean;
	    poll_ms: number;
	    delay_ms: number;
	    offset_on: boolean;
	    offset_hz: number;
	    digital_default: string;
	    share_enabled: boolean;
	    share_port: number;
	    share_proto: string;
	    share_tci_port: number;
	    ptt_hotkey_enabled: boolean;
	    ptt_hotkey: string;
	    ptt_hotkey_toggle: boolean;
	
	    static createFrom(source: any = {}) {
	        return new CATSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.backend = source["backend"];
	        this.omnirig_rig = source["omnirig_rig"];
	        this.omnirig_vfo = source["omnirig_vfo"];
	        this.digi_as_usb = source["digi_as_usb"];
	        this.flex_host = source["flex_host"];
	        this.flex_port = source["flex_port"];
	        this.flex_spots = source["flex_spots"];
	        this.flex_dvk_dax = source["flex_dvk_dax"];
	        this.flex_decode_spots = source["flex_decode_spots"];
	        this.flex_decode_secs = source["flex_decode_secs"];
	        this.xiegu_port = source["xiegu_port"];
	        this.xiegu_baud = source["xiegu_baud"];
	        this.xiegu_addr = source["xiegu_addr"];
	        this.xiegu_ptt_line = source["xiegu_ptt_line"];
	        this.yaesu_port = source["yaesu_port"];
	        this.yaesu_baud = source["yaesu_baud"];
	        this.kenwood_host = source["kenwood_host"];
	        this.kenwood_port = source["kenwood_port"];
	        this.kenwood_link = source["kenwood_link"];
	        this.kenwood_baud = source["kenwood_baud"];
	        this.kenwood_data_mode = source["kenwood_data_mode"];
	        this.yaesu_low_lines = source["yaesu_low_lines"];
	        this.yaesu_rtty_usb = source["yaesu_rtty_usb"];
	        this.kenwood_low_lines = source["kenwood_low_lines"];
	        this.icom_port = source["icom_port"];
	        this.icom_baud = source["icom_baud"];
	        this.icom_addr = source["icom_addr"];
	        this.icom_net_host = source["icom_net_host"];
	        this.icom_net_user = source["icom_net_user"];
	        this.icom_net_pass = source["icom_net_pass"];
	        this.icom_net_audio = source["icom_net_audio"];
	        this.tci_host = source["tci_host"];
	        this.tci_port = source["tci_port"];
	        this.tci_spots = source["tci_spots"];
	        this.poll_ms = source["poll_ms"];
	        this.delay_ms = source["delay_ms"];
	        this.offset_on = source["offset_on"];
	        this.offset_hz = source["offset_hz"];
	        this.digital_default = source["digital_default"];
	        this.share_enabled = source["share_enabled"];
	        this.share_port = source["share_port"];
	        this.share_proto = source["share_proto"];
	        this.share_tci_port = source["share_tci_port"];
	        this.ptt_hotkey_enabled = source["ptt_hotkey_enabled"];
	        this.ptt_hotkey = source["ptt_hotkey"];
	        this.ptt_hotkey_toggle = source["ptt_hotkey_toggle"];
	    }
	}
	export class CabrilloResult {
	    count: number;
	    path: string;
	
	    static createFrom(source: any = {}) {
	        return new CabrilloResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.path = source["path"];
	    }
	}
	export class ChangelogEntry {
	    version: string;
	    date: string;
	    en: string[];
	    fr: string[];
	
	    static createFrom(source: any = {}) {
	        return new ChangelogEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.version = source["version"];
	        this.date = source["date"];
	        this.en = source["en"];
	        this.fr = source["fr"];
	    }
	}
	export class ChaseNewSpot {
	    call: string;
	    band: string;
	    mode: string;
	    freq_hz: number;
	    grid: string;
	    country?: string;
	    cont?: string;
	    dist_km: number;
	    bearing: number;
	    status?: string;
	    new_pfx?: boolean;
	    new_grid?: boolean;
	    lotw?: boolean;
	    at: string;
	
	    static createFrom(source: any = {}) {
	        return new ChaseNewSpot(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.call = source["call"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.freq_hz = source["freq_hz"];
	        this.grid = source["grid"];
	        this.country = source["country"];
	        this.cont = source["cont"];
	        this.dist_km = source["dist_km"];
	        this.bearing = source["bearing"];
	        this.status = source["status"];
	        this.new_pfx = source["new_pfx"];
	        this.new_grid = source["new_grid"];
	        this.lotw = source["lotw"];
	        this.at = source["at"];
	    }
	}
	export class ChaseSettings {
	    mode: string;
	    sources: string[];
	
	    static createFrom(source: any = {}) {
	        return new ChaseSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.mode = source["mode"];
	        this.sources = source["sources"];
	    }
	}
	export class ChatMessage {
	    id: number;
	    operator: string;
	    station: string;
	    message: string;
	    created_at: string;
	
	    static createFrom(source: any = {}) {
	        return new ChatMessage(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.operator = source["operator"];
	        this.station = source["station"];
	        this.message = source["message"];
	        this.created_at = source["created_at"];
	    }
	}
	export class ChatPresence {
	    operator: string;
	    station: string;
	    ago_secs: number;
	
	    static createFrom(source: any = {}) {
	        return new ChatPresence(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.operator = source["operator"];
	        this.station = source["station"];
	        this.ago_secs = source["ago_secs"];
	    }
	}
	export class ClublogCtyInfo {
	    enabled: boolean;
	    loaded: boolean;
	    date: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new ClublogCtyInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.loaded = source["loaded"];
	        this.date = source["date"];
	        this.count = source["count"];
	    }
	}
	export class ClublogMostWantedInfo {
	    enabled: boolean;
	    loaded: boolean;
	    callsign: string;
	    date: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new ClublogMostWantedInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.loaded = source["loaded"];
	        this.callsign = source["callsign"];
	        this.date = source["date"];
	        this.count = source["count"];
	    }
	}
	export class CompactResult {
	    path: string;
	    backend: string;
	    before: number;
	    after: number;
	
	    static createFrom(source: any = {}) {
	        return new CompactResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.backend = source["backend"];
	        this.before = source["before"];
	        this.after = source["after"];
	    }
	}
	export class ContestBandRow {
	    band: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new ContestBandRow(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.count = source["count"];
	    }
	}
	export class ContestStatsResult {
	    qsos: number;
	    by_band: ContestBandRow[];
	    mult: number;
	    mult_label: string;
	    score: number;
	    last_hour: number;
	
	    static createFrom(source: any = {}) {
	        return new ContestStatsResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qsos = source["qsos"];
	        this.by_band = this.convertValues(source["by_band"], ContestBandRow);
	        this.mult = source["mult"];
	        this.mult_label = source["mult_label"];
	        this.score = source["score"];
	        this.last_hour = source["last_hour"];
	    }
	
		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 CtyDatInfo {
	    path: string;
	    entities: number;
	    loaded_at?: string;
	    file_mod_time?: string;
	
	    static createFrom(source: any = {}) {
	        return new CtyDatInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.entities = source["entities"];
	        this.loaded_at = source["loaded_at"];
	        this.file_mod_time = source["file_mod_time"];
	    }
	}
	export class DBBackendStatus {
	    active: string;
	    fallback: boolean;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new DBBackendStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.active = source["active"];
	        this.fallback = source["fallback"];
	        this.error = source["error"];
	    }
	}
	export class DBConnectionInfo {
	    backend: string;
	    label: string;
	
	    static createFrom(source: any = {}) {
	        return new DBConnectionInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.backend = source["backend"];
	        this.label = source["label"];
	    }
	}
	export class DVKMessage {
	    slot: number;
	    label: string;
	    has_audio: boolean;
	    duration_sec: number;
	
	    static createFrom(source: any = {}) {
	        return new DVKMessage(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.slot = source["slot"];
	        this.label = source["label"];
	        this.has_audio = source["has_audio"];
	        this.duration_sec = source["duration_sec"];
	    }
	}
	export class DVKStatus {
	    recording: boolean;
	    playing: boolean;
	    rec_slot: number;
	
	    static createFrom(source: any = {}) {
	        return new DVKStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.recording = source["recording"];
	        this.playing = source["playing"];
	        this.rec_slot = source["rec_slot"];
	    }
	}
	export class DXpedition {
	    dxcc: string;
	    callsign: string;
	    calls: string[];
	    start_date: string;
	    end_date: string;
	    bands: string[];
	    modes: string[];
	    qsl: string;
	    operators: string;
	    source: string;
	    link: string;
	    status: string;
	    status_chase: string;
	    unconfirmed: boolean;
	
	    static createFrom(source: any = {}) {
	        return new DXpedition(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.dxcc = source["dxcc"];
	        this.callsign = source["callsign"];
	        this.calls = source["calls"];
	        this.start_date = source["start_date"];
	        this.end_date = source["end_date"];
	        this.bands = source["bands"];
	        this.modes = source["modes"];
	        this.qsl = source["qsl"];
	        this.operators = source["operators"];
	        this.source = source["source"];
	        this.link = source["link"];
	        this.status = source["status"];
	        this.status_chase = source["status_chase"];
	        this.unconfirmed = source["unconfirmed"];
	    }
	}
	export class DatabaseSettings {
	    path: string;
	    default_path: string;
	    is_custom: boolean;
	    logbook_default_path: string;
	
	    static createFrom(source: any = {}) {
	        return new DatabaseSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.default_path = source["default_path"];
	        this.is_custom = source["is_custom"];
	        this.logbook_default_path = source["logbook_default_path"];
	    }
	}
	export class DuplicateGroup {
	    key: string;
	    qsos: qso.QSO[];
	
	    static createFrom(source: any = {}) {
	        return new DuplicateGroup(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.key = source["key"];
	        this.qsos = this.convertValues(source["qsos"], qso.QSO);
	    }
	
		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 EmailSettings {
	    enabled: boolean;
	    smtp_host: string;
	    smtp_port: number;
	    smtp_user: string;
	    smtp_password: string;
	    from: string;
	    reply_to: string;
	    encryption: string;
	    auth: boolean;
	    auto_send: boolean;
	    subject: string;
	    body: string;
	
	    static createFrom(source: any = {}) {
	        return new EmailSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.smtp_host = source["smtp_host"];
	        this.smtp_port = source["smtp_port"];
	        this.smtp_user = source["smtp_user"];
	        this.smtp_password = source["smtp_password"];
	        this.from = source["from"];
	        this.reply_to = source["reply_to"];
	        this.encryption = source["encryption"];
	        this.auth = source["auth"];
	        this.auto_send = source["auto_send"];
	        this.subject = source["subject"];
	        this.body = source["body"];
	    }
	}
	export class FlexRSTChase {
	    enabled: boolean;
	    markers: string;
	    offset_hz: number;
	    split_only: boolean;
	
	    static createFrom(source: any = {}) {
	        return new FlexRSTChase(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.markers = source["markers"];
	        this.offset_hz = source["offset_hz"];
	        this.split_only = source["split_only"];
	    }
	}
	export class FlexZoomSettings {
	    enabled: boolean;
	    cw_khz: number;
	    ssb_khz: number;
	    digi_khz: number;
	    centre: boolean;
	
	    static createFrom(source: any = {}) {
	        return new FlexZoomSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.cw_khz = source["cw_khz"];
	        this.ssb_khz = source["ssb_khz"];
	        this.digi_khz = source["digi_khz"];
	        this.centre = source["centre"];
	    }
	}
	export class FolderSyncConfig {
	    enabled: boolean;
	    folder: string;
	    machine: string;
	
	    static createFrom(source: any = {}) {
	        return new FolderSyncConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.folder = source["folder"];
	        this.machine = source["machine"];
	    }
	}
	export class FolderSyncPeer {
	    machine: string;
	    last_change: string;
	    behind: number;
	
	    static createFrom(source: any = {}) {
	        return new FolderSyncPeer(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.machine = source["machine"];
	        this.last_change = source["last_change"];
	        this.behind = source["behind"];
	    }
	}
	export class FolderSyncStatus {
	    enabled: boolean;
	    folder: string;
	    machine_id: string;
	    peers: FolderSyncPeer[];
	    last_sync: string;
	    sent: number;
	    received: number;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new FolderSyncStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.folder = source["folder"];
	        this.machine_id = source["machine_id"];
	        this.peers = this.convertValues(source["peers"], FolderSyncPeer);
	        this.last_sync = source["last_sync"];
	        this.sent = source["sent"];
	        this.received = source["received"];
	        this.error = source["error"];
	    }
	
		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 GridCacheStatus {
	    enabled: boolean;
	    known: number;
	    pending: number;
	
	    static createFrom(source: any = {}) {
	        return new GridCacheStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.known = source["known"];
	        this.pending = source["pending"];
	    }
	}
	export class gridScope {
	    key: string;
	    band: boolean;
	    mode: string;
	
	    static createFrom(source: any = {}) {
	        return new gridScope(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.key = source["key"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	    }
	}
	export class GridScopeSettings {
	    scope: string;
	    hunt: string;
	    scopes: gridScope[];
	
	    static createFrom(source: any = {}) {
	        return new GridScopeSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.scope = source["scope"];
	        this.hunt = source["hunt"];
	        this.scopes = this.convertValues(source["scopes"], gridScope);
	    }
	
		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 HamlogCfmResult {
	    total: number;
	    confirmed: number;
	    matched: number;
	    by_class: number;
	    unmatched: number;
	    samples: string[];
	
	    static createFrom(source: any = {}) {
	        return new HamlogCfmResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.confirmed = source["confirmed"];
	        this.matched = source["matched"];
	        this.by_class = source["by_class"];
	        this.unmatched = source["unmatched"];
	        this.samples = source["samples"];
	    }
	}
	export class ModePreset {
	    name: string;
	    default_rst_sent?: string;
	    default_rst_rcvd?: string;
	
	    static createFrom(source: any = {}) {
	        return new ModePreset(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.default_rst_sent = source["default_rst_sent"];
	        this.default_rst_rcvd = source["default_rst_rcvd"];
	    }
	}
	export class ListsSettings {
	    bands: string[];
	    modes: ModePreset[];
	    rst_phone: string[];
	    rst_cw: string[];
	    rst_digital: string[];
	    satellites: string[];
	
	    static createFrom(source: any = {}) {
	        return new ListsSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.bands = source["bands"];
	        this.modes = this.convertValues(source["modes"], ModePreset);
	        this.rst_phone = source["rst_phone"];
	        this.rst_cw = source["rst_cw"];
	        this.rst_digital = source["rst_digital"];
	        this.satellites = source["satellites"];
	    }
	
		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 LiveStation {
	    operator: string;
	    station: string;
	    freq_hz: number;
	    band: string;
	    mode: string;
	    online: boolean;
	    version: string;
	    age_sec: number;
	
	    static createFrom(source: any = {}) {
	        return new LiveStation(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.operator = source["operator"];
	        this.station = source["station"];
	        this.freq_hz = source["freq_hz"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.online = source["online"];
	        this.version = source["version"];
	        this.age_sec = source["age_sec"];
	    }
	}
	export class LoTWUsersStatus {
	    count: number;
	    updated?: string;
	
	    static createFrom(source: any = {}) {
	        return new LoTWUsersStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.updated = source["updated"];
	    }
	}
	export class LookupSettings {
	    qrz_user: string;
	    qrz_password: string;
	    hamqth_user: string;
	    hamqth_password: string;
	    primary: string;
	    failsafe: string;
	    download_images: boolean;
	    qrz_prefer_nickname: boolean;
	    cache_ttl_days: number;
	
	    static createFrom(source: any = {}) {
	        return new LookupSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qrz_user = source["qrz_user"];
	        this.qrz_password = source["qrz_password"];
	        this.hamqth_user = source["hamqth_user"];
	        this.hamqth_password = source["hamqth_password"];
	        this.primary = source["primary"];
	        this.failsafe = source["failsafe"];
	        this.download_images = source["download_images"];
	        this.qrz_prefer_nickname = source["qrz_prefer_nickname"];
	        this.cache_ttl_days = source["cache_ttl_days"];
	    }
	}
	export class MatrixColors {
	    enabled: boolean;
	    call_confirmed: string;
	    call_worked: string;
	    entity_confirmed: string;
	    entity_worked: string;
	    not_worked: string;
	    current_entry: string;
	    mark_worked: string;
	    mark_confirmed: string;
	
	    static createFrom(source: any = {}) {
	        return new MatrixColors(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.call_confirmed = source["call_confirmed"];
	        this.call_worked = source["call_worked"];
	        this.entity_confirmed = source["entity_confirmed"];
	        this.entity_worked = source["entity_worked"];
	        this.not_worked = source["not_worked"];
	        this.current_entry = source["current_entry"];
	        this.mark_worked = source["mark_worked"];
	        this.mark_confirmed = source["mark_confirmed"];
	    }
	}
	
	export class MySQLSettings {
	    enabled: boolean;
	    host: string;
	    port: number;
	    user: string;
	    password: string;
	    database: string;
	    sqlite_path?: string;
	
	    static createFrom(source: any = {}) {
	        return new MySQLSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.user = source["user"];
	        this.password = source["password"];
	        this.database = source["database"];
	        this.sqlite_path = source["sqlite_path"];
	    }
	}
	export class OfflineStatus {
	    offline: boolean;
	    pending: number;
	    path: string;
	
	    static createFrom(source: any = {}) {
	        return new OfflineStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.offline = source["offline"];
	        this.pending = source["pending"];
	        this.path = source["path"];
	    }
	}
	export class PGXLSettings {
	    enabled: boolean;
	    type: string;
	    transport: string;
	    host: string;
	    port: number;
	    com_port: string;
	    baud: number;
	
	    static createFrom(source: any = {}) {
	        return new PGXLSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.type = source["type"];
	        this.transport = source["transport"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.com_port = source["com_port"];
	        this.baud = source["baud"];
	    }
	}
	export class POTAUnmatched {
	    activator: string;
	    date: string;
	    band: string;
	    reference: string;
	    reason: string;
	    qso_id: number;
	
	    static createFrom(source: any = {}) {
	        return new POTAUnmatched(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.activator = source["activator"];
	        this.date = source["date"];
	        this.band = source["band"];
	        this.reference = source["reference"];
	        this.reason = source["reason"];
	        this.qso_id = source["qso_id"];
	    }
	}
	export class POTASyncResult {
	    fetched: number;
	    updated: number;
	    already_tagged: number;
	    added: number;
	    unmatched: number;
	    unmatched_list: POTAUnmatched[];
	    skipped_other_call: number;
	    my_call: string;
	
	    static createFrom(source: any = {}) {
	        return new POTASyncResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.fetched = source["fetched"];
	        this.updated = source["updated"];
	        this.already_tagged = source["already_tagged"];
	        this.added = source["added"];
	        this.unmatched = source["unmatched"];
	        this.unmatched_list = this.convertValues(source["unmatched_list"], POTAUnmatched);
	        this.skipped_other_call = source["skipped_other_call"];
	        this.my_call = source["my_call"];
	    }
	
		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 PSKTargetSettings {
	    enabled: boolean;
	    scope: string;
	
	    static createFrom(source: any = {}) {
	        return new PSKTargetSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.scope = source["scope"];
	    }
	}
	export class PSUSettings {
	    enabled: boolean;
	    com_port: string;
	    baud: number;
	    address: number;
	
	    static createFrom(source: any = {}) {
	        return new PSUSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.com_port = source["com_port"];
	        this.baud = source["baud"];
	        this.address = source["address"];
	    }
	}
	export class QSLBulkUpdate {
	    sent_status: string;
	    rcvd_status: string;
	    sent_date: string;
	    rcvd_date: string;
	    via: string;
	    rcvd_via: string;
	    notes: string;
	    comment: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLBulkUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.sent_status = source["sent_status"];
	        this.rcvd_status = source["rcvd_status"];
	        this.sent_date = source["sent_date"];
	        this.rcvd_date = source["rcvd_date"];
	        this.via = source["via"];
	        this.rcvd_via = source["rcvd_via"];
	        this.notes = source["notes"];
	        this.comment = source["comment"];
	    }
	}
	export class QSLDefaults {
	    qsl_sent: string;
	    qsl_rcvd: string;
	    lotw_sent: string;
	    lotw_rcvd: string;
	    eqsl_sent: string;
	    eqsl_rcvd: string;
	    clublog_status: string;
	    clublog_confirmed: string;
	    hrdlog_status: string;
	    qrzcom_status: string;
	    qrzcom_confirmed: string;
	    hamlog_status: string;
	    hamlog_confirmed: string;
	    hamqth_status: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLDefaults(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qsl_sent = source["qsl_sent"];
	        this.qsl_rcvd = source["qsl_rcvd"];
	        this.lotw_sent = source["lotw_sent"];
	        this.lotw_rcvd = source["lotw_rcvd"];
	        this.eqsl_sent = source["eqsl_sent"];
	        this.eqsl_rcvd = source["eqsl_rcvd"];
	        this.clublog_status = source["clublog_status"];
	        this.clublog_confirmed = source["clublog_confirmed"];
	        this.hrdlog_status = source["hrdlog_status"];
	        this.qrzcom_status = source["qrzcom_status"];
	        this.qrzcom_confirmed = source["qrzcom_confirmed"];
	        this.hamlog_status = source["hamlog_status"];
	        this.hamlog_confirmed = source["hamlog_confirmed"];
	        this.hamqth_status = source["hamqth_status"];
	    }
	}
	export class QSLEmailTemplates {
	    subject: string;
	    body: string;
	    auto_send: boolean;
	    default_message: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLEmailTemplates(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.subject = source["subject"];
	        this.body = source["body"];
	        this.auto_send = source["auto_send"];
	        this.default_message = source["default_message"];
	    }
	}
	export class QSLFontInfo {
	    family: string;
	    kind: string;
	    variable: boolean;
	    data_b64: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLFontInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.family = source["family"];
	        this.kind = source["kind"];
	        this.variable = source["variable"];
	        this.data_b64 = source["data_b64"];
	    }
	}
	export class QSLForeignTemplate {
	    id: number;
	    name: string;
	    profile_id: number;
	    profile_name: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLForeignTemplate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.profile_id = source["profile_id"];
	        this.profile_name = source["profile_name"];
	    }
	}
	export class QSLPresetInfo {
	    name: string;
	    label: string;
	    params: string[];
	    defaults: qslcard.StyleParams;
	
	    static createFrom(source: any = {}) {
	        return new QSLPresetInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.label = source["label"];
	        this.params = source["params"];
	        this.defaults = this.convertValues(source["defaults"], qslcard.StyleParams);
	    }
	
		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 QSLTemplateInfo {
	    id: number;
	    name: string;
	    profile_id?: number;
	    is_default: boolean;
	    updated_at: string;
	
	    static createFrom(source: any = {}) {
	        return new QSLTemplateInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.profile_id = source["profile_id"];
	        this.is_default = source["is_default"];
	        this.updated_at = source["updated_at"];
	    }
	}
	export class QSLViaRepairResult {
	    moved: number;
	
	    static createFrom(source: any = {}) {
	        return new QSLViaRepairResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.moved = source["moved"];
	    }
	}
	export class QSLViaRepairStatus {
	    affected: number;
	    asked: boolean;
	
	    static createFrom(source: any = {}) {
	        return new QSLViaRepairStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.affected = source["affected"];
	        this.asked = source["asked"];
	    }
	}
	export class QSOAwardRef {
	    code: string;
	    ref: string;
	    name?: string;
	    pickable: boolean;
	    ambiguous?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new QSOAwardRef(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.ref = source["ref"];
	        this.name = source["name"];
	        this.pickable = source["pickable"];
	        this.ambiguous = source["ambiguous"];
	    }
	}
	export class QSORate {
	    last10: number;
	    last60: number;
	    team_last10: number;
	    team_last60: number;
	
	    static createFrom(source: any = {}) {
	        return new QSORate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.last10 = source["last10"];
	        this.last60 = source["last60"];
	        this.team_last10 = source["team_last10"];
	        this.team_last60 = source["team_last60"];
	    }
	}
	export class RDAApplyResult {
	    applied: number;
	    failed: number;
	    message: string;
	
	    static createFrom(source: any = {}) {
	        return new RDAApplyResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.applied = source["applied"];
	        this.failed = source["failed"];
	        this.message = source["message"];
	    }
	}
	export class RDAChoice {
	    qso_id: number;
	    district: string;
	
	    static createFrom(source: any = {}) {
	        return new RDAChoice(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qso_id = source["qso_id"];
	        this.district = source["district"];
	    }
	}
	export class RDAConflict {
	    qso_id: number;
	    callsign: string;
	    date: string;
	    band: string;
	    mode: string;
	    from_log: string;
	    from_db: string;
	    dated: boolean;
	    confirmed: boolean;
	
	    static createFrom(source: any = {}) {
	        return new RDAConflict(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qso_id = source["qso_id"];
	        this.callsign = source["callsign"];
	        this.date = source["date"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.from_log = source["from_log"];
	        this.from_db = source["from_db"];
	        this.dated = source["dated"];
	        this.confirmed = source["confirmed"];
	    }
	}
	export class RDACompareResult {
	    scanned: number;
	    both_known: number;
	    agree: number;
	    disagree: number;
	    only_log: number;
	    only_db: number;
	    neither: number;
	    conflicts: RDAConflict[];
	
	    static createFrom(source: any = {}) {
	        return new RDACompareResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.scanned = source["scanned"];
	        this.both_known = source["both_known"];
	        this.agree = source["agree"];
	        this.disagree = source["disagree"];
	        this.only_log = source["only_log"];
	        this.only_db = source["only_db"];
	        this.neither = source["neither"];
	        this.conflicts = this.convertValues(source["conflicts"], RDAConflict);
	    }
	
		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 RadioConfig {
	    id: string;
	    name: string;
	    settings: CATSettings;
	    my_rig: string;
	
	    static createFrom(source: any = {}) {
	        return new RadioConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.settings = this.convertValues(source["settings"], CATSettings);
	        this.my_rig = source["my_rig"];
	    }
	
		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 RadioListEntry {
	    id: string;
	    name: string;
	    label: string;
	    backend: string;
	    active: boolean;
	
	    static createFrom(source: any = {}) {
	        return new RadioListEntry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.label = source["label"];
	        this.backend = source["backend"];
	        this.active = source["active"];
	    }
	}
	export class RelayAutoRule {
	    device_id: string;
	    relay: number;
	    mode: string;
	    freq_lo_khz: number;
	    freq_hi_khz: number;
	    bands: string[];
	
	    static createFrom(source: any = {}) {
	        return new RelayAutoRule(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.device_id = source["device_id"];
	        this.relay = source["relay"];
	        this.mode = source["mode"];
	        this.freq_lo_khz = source["freq_lo_khz"];
	        this.freq_hi_khz = source["freq_hi_khz"];
	        this.bands = source["bands"];
	    }
	}
	export class RelayAutoConfig {
	    enabled: boolean;
	    rules: RelayAutoRule[];
	
	    static createFrom(source: any = {}) {
	        return new RelayAutoConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.rules = this.convertValues(source["rules"], RelayAutoRule);
	    }
	
		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 RotatorDevice {
	    id: string;
	    name: string;
	    type: string;
	    host: string;
	    port: number;
	    has_elevation: boolean;
	    rotator_num: number;
	    dual: boolean;
	    motorized: boolean;
	    name2: string;
	    motorized2: boolean;
	    transport: string;
	    com_port: string;
	    baud: number;
	    spid_model?: string;
	
	    static createFrom(source: any = {}) {
	        return new RotatorDevice(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.type = source["type"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.has_elevation = source["has_elevation"];
	        this.rotator_num = source["rotator_num"];
	        this.dual = source["dual"];
	        this.motorized = source["motorized"];
	        this.name2 = source["name2"];
	        this.motorized2 = source["motorized2"];
	        this.transport = source["transport"];
	        this.com_port = source["com_port"];
	        this.baud = source["baud"];
	        this.spid_model = source["spid_model"];
	    }
	}
	export class RotatorHeading {
	    enabled: boolean;
	    ok: boolean;
	    azimuth: number;
	    raw: string;
	    rotors: string[];
	    active: number;
	    motorized: boolean;
	
	    static createFrom(source: any = {}) {
	        return new RotatorHeading(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.ok = source["ok"];
	        this.azimuth = source["azimuth"];
	        this.raw = source["raw"];
	        this.rotors = source["rotors"];
	        this.active = source["active"];
	        this.motorized = source["motorized"];
	    }
	}
	export class RotorPreset {
	    label: string;
	    azimuth: number;
	
	    static createFrom(source: any = {}) {
	        return new RotorPreset(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.azimuth = source["azimuth"];
	    }
	}
	export class RowColorRule {
	    id: string;
	    color: string;
	    enabled: boolean;
	    channels: string[];
	
	    static createFrom(source: any = {}) {
	        return new RowColorRule(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.color = source["color"];
	        this.enabled = source["enabled"];
	        this.channels = source["channels"];
	    }
	}
	export class RowColorSettings {
	    enabled: boolean;
	    style: string;
	    intensity: number;
	    bandmap_lotw: boolean;
	    recent_zebra?: string;
	    recent_zebra_color?: string;
	    configured: boolean;
	    rules: RowColorRule[];
	
	    static createFrom(source: any = {}) {
	        return new RowColorSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.style = source["style"];
	        this.intensity = source["intensity"];
	        this.bandmap_lotw = source["bandmap_lotw"];
	        this.recent_zebra = source["recent_zebra"];
	        this.recent_zebra_color = source["recent_zebra_color"];
	        this.configured = source["configured"];
	        this.rules = this.convertValues(source["rules"], RowColorRule);
	    }
	
		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 SatTransponder {
	    label: string;
	    mode: string;
	    down_lo: number;
	    down_hi: number;
	    up_lo: number;
	    up_hi: number;
	    inverting: boolean;
	    ctcss: number;
	    linear: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SatTransponder(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.mode = source["mode"];
	        this.down_lo = source["down_lo"];
	        this.down_hi = source["down_hi"];
	        this.up_lo = source["up_lo"];
	        this.up_hi = source["up_hi"];
	        this.inverting = source["inverting"];
	        this.ctcss = source["ctcss"];
	        this.linear = source["linear"];
	    }
	}
	export class SatBird {
	    name: string;
	    norad: number;
	    geostationary: boolean;
	    favorite: boolean;
	    has_elements: boolean;
	    element_name: string;
	    epoch_age_h: number;
	    transponders: SatTransponder[];
	
	    static createFrom(source: any = {}) {
	        return new SatBird(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.norad = source["norad"];
	        this.geostationary = source["geostationary"];
	        this.favorite = source["favorite"];
	        this.has_elements = source["has_elements"];
	        this.element_name = source["element_name"];
	        this.epoch_age_h = source["epoch_age_h"];
	        this.transponders = this.convertValues(source["transponders"], SatTransponder);
	    }
	
		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 SatPassInfo {
	    name: string;
	    has_pass: boolean;
	    in_pass: boolean;
	    // Go type: time
	    aos: any;
	    // Go type: time
	    los: any;
	    aos_az: number;
	    los_az: number;
	    max_el: number;
	    max_el_az: number;
	    // Go type: time
	    max_el_at: any;
	    duration_s: number;
	
	    static createFrom(source: any = {}) {
	        return new SatPassInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.has_pass = source["has_pass"];
	        this.in_pass = source["in_pass"];
	        this.aos = this.convertValues(source["aos"], null);
	        this.los = this.convertValues(source["los"], null);
	        this.aos_az = source["aos_az"];
	        this.los_az = source["los_az"];
	        this.max_el = source["max_el"];
	        this.max_el_az = source["max_el_az"];
	        this.max_el_at = this.convertValues(source["max_el_at"], null);
	        this.duration_s = source["duration_s"];
	    }
	
		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 SatSettings {
	    favorites: string[];
	    min_el: number;
	    window_h: number;
	    auto_tle: boolean;
	    grid: string;
	    alt_m: number;
	    rot_on: boolean;
	    rot_type: string;
	    rot_pst_port: number;
	    rot_transport: string;
	    rot_host: string;
	    rot_port: number;
	    rot_com: string;
	    rot_baud: number;
	    rot_max_az: number;
	    rot_min_el: number;
	    rot_step: number;
	    rot_park: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SatSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.favorites = source["favorites"];
	        this.min_el = source["min_el"];
	        this.window_h = source["window_h"];
	        this.auto_tle = source["auto_tle"];
	        this.grid = source["grid"];
	        this.alt_m = source["alt_m"];
	        this.rot_on = source["rot_on"];
	        this.rot_type = source["rot_type"];
	        this.rot_pst_port = source["rot_pst_port"];
	        this.rot_transport = source["rot_transport"];
	        this.rot_host = source["rot_host"];
	        this.rot_port = source["rot_port"];
	        this.rot_com = source["rot_com"];
	        this.rot_baud = source["rot_baud"];
	        this.rot_max_az = source["rot_max_az"];
	        this.rot_min_el = source["rot_min_el"];
	        this.rot_step = source["rot_step"];
	        this.rot_park = source["rot_park"];
	    }
	}
	export class SatSkyPoint {
	    // Go type: time
	    at: any;
	    az: number;
	    el: number;
	
	    static createFrom(source: any = {}) {
	        return new SatSkyPoint(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.at = this.convertValues(source["at"], null);
	        this.az = source["az"];
	        this.el = source["el"];
	    }
	
		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 SatTLEInfo {
	    count: number;
	    // Go type: time
	    fetched_at: any;
	    age_h: number;
	    stale: boolean;
	    custom: number;
	
	    static createFrom(source: any = {}) {
	        return new SatTLEInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.fetched_at = this.convertValues(source["fetched_at"], null);
	        this.age_h = source["age_h"];
	        this.stale = source["stale"];
	        this.custom = source["custom"];
	    }
	
		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 SatTrackStatus {
	    on: boolean;
	    name: string;
	    transponder: string;
	    mode: string;
	    nominal_down: number;
	    nominal_up: number;
	    down_hz: number;
	    up_hz: number;
	    az: number;
	    el: number;
	    visible: boolean;
	    radio: string;
	    error: string;
	    rot_on: boolean;
	    rot_az: number;
	    rot_el: number;
	    rot_live: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SatTrackStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.on = source["on"];
	        this.name = source["name"];
	        this.transponder = source["transponder"];
	        this.mode = source["mode"];
	        this.nominal_down = source["nominal_down"];
	        this.nominal_up = source["nominal_up"];
	        this.down_hz = source["down_hz"];
	        this.up_hz = source["up_hz"];
	        this.az = source["az"];
	        this.el = source["el"];
	        this.visible = source["visible"];
	        this.radio = source["radio"];
	        this.error = source["error"];
	        this.rot_on = source["rot_on"];
	        this.rot_az = source["rot_az"];
	        this.rot_el = source["rot_el"];
	        this.rot_live = source["rot_live"];
	    }
	}
	
	export class SatTuning {
	    name: string;
	    transponder: string;
	    mode: string;
	    nominal_down: number;
	    nominal_up: number;
	    down_hz: number;
	    up_hz: number;
	    ctcss: number;
	    inverting: boolean;
	    az: number;
	    el: number;
	    range_km: number;
	    range_rate: number;
	    visible: boolean;
	    // Go type: time
	    at: any;
	    lat: number;
	    lon: number;
	    alt_km: number;
	    footprint_km: number;
	
	    static createFrom(source: any = {}) {
	        return new SatTuning(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.transponder = source["transponder"];
	        this.mode = source["mode"];
	        this.nominal_down = source["nominal_down"];
	        this.nominal_up = source["nominal_up"];
	        this.down_hz = source["down_hz"];
	        this.up_hz = source["up_hz"];
	        this.ctcss = source["ctcss"];
	        this.inverting = source["inverting"];
	        this.az = source["az"];
	        this.el = source["el"];
	        this.range_km = source["range_km"];
	        this.range_rate = source["range_rate"];
	        this.visible = source["visible"];
	        this.at = this.convertValues(source["at"], null);
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	        this.alt_km = source["alt_km"];
	        this.footprint_km = source["footprint_km"];
	    }
	
		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 ScpStatus {
	    enabled: boolean;
	    count: number;
	    updated?: string;
	    clublog: boolean;
	
	    static createFrom(source: any = {}) {
	        return new ScpStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.count = source["count"];
	        this.updated = source["updated"];
	        this.clublog = source["clublog"];
	    }
	}
	export class SecretStatus {
	    has_passphrase: boolean;
	    unlocked: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SecretStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.has_passphrase = source["has_passphrase"];
	        this.unlocked = source["unlocked"];
	    }
	}
	export class SelfSpotSettings {
	    enabled: boolean;
	    minutes: number;
	
	    static createFrom(source: any = {}) {
	        return new SelfSpotSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.minutes = source["minutes"];
	    }
	}
	export class SpotColor {
	    text: string;
	    bg?: string;
	    hide?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SpotColor(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.text = source["text"];
	        this.bg = source["bg"];
	        this.hide = source["hide"];
	    }
	}
	export class SpotColors {
	    enabled: boolean;
	    colors: Record<string, SpotColor>;
	
	    static createFrom(source: any = {}) {
	        return new SpotColors(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.colors = this.convertValues(source["colors"], SpotColor, 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 SpotQuery {
	    call: string;
	    band: string;
	    mode: string;
	    pota_ref?: string;
	    spotter?: string;
	
	    static createFrom(source: any = {}) {
	        return new SpotQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.call = source["call"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.pota_ref = source["pota_ref"];
	        this.spotter = source["spotter"];
	    }
	}
	export class SpotStatus {
	    call: string;
	    band: string;
	    mode: string;
	    country?: string;
	    continent?: string;
	    status: string;
	    worked_call: boolean;
	    new_county: boolean;
	    county?: string;
	    state?: string;
	    new_state: boolean;
	    unconf_status?: boolean;
	    unconf_pfx?: boolean;
	    unconf_cty?: boolean;
	    unconf_state?: boolean;
	    new_pota: boolean;
	    grid?: string;
	    new_grid: boolean;
	    grid_state?: string;
	    spotter_continent?: string;
	    lotw: boolean;
	    new_pfx: boolean;
	    pfx?: string;
	    worked_slot: boolean;
	
	    static createFrom(source: any = {}) {
	        return new SpotStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.call = source["call"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.country = source["country"];
	        this.continent = source["continent"];
	        this.status = source["status"];
	        this.worked_call = source["worked_call"];
	        this.new_county = source["new_county"];
	        this.county = source["county"];
	        this.state = source["state"];
	        this.new_state = source["new_state"];
	        this.unconf_status = source["unconf_status"];
	        this.unconf_pfx = source["unconf_pfx"];
	        this.unconf_cty = source["unconf_cty"];
	        this.unconf_state = source["unconf_state"];
	        this.new_pota = source["new_pota"];
	        this.grid = source["grid"];
	        this.new_grid = source["new_grid"];
	        this.grid_state = source["grid_state"];
	        this.spotter_continent = source["spotter_continent"];
	        this.lotw = source["lotw"];
	        this.new_pfx = source["new_pfx"];
	        this.pfx = source["pfx"];
	        this.worked_slot = source["worked_slot"];
	    }
	}
	export class StartupStatus {
	    ok: boolean;
	    err: string;
	    db_path: string;
	
	    static createFrom(source: any = {}) {
	        return new StartupStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ok = source["ok"];
	        this.err = source["err"];
	        this.db_path = source["db_path"];
	    }
	}
	export class StationDevice {
	    id: string;
	    type: string;
	    name: string;
	    host: string;
	    user?: string;
	    pass?: string;
	    channels?: number;
	    labels: string[];
	    on_urls?: string[];
	    off_urls?: string[];
	    on_pattern?: string;
	    off_pattern?: string;
	    insecure_tls?: boolean;
	
	    static createFrom(source: any = {}) {
	        return new StationDevice(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.type = source["type"];
	        this.name = source["name"];
	        this.host = source["host"];
	        this.user = source["user"];
	        this.pass = source["pass"];
	        this.channels = source["channels"];
	        this.labels = source["labels"];
	        this.on_urls = source["on_urls"];
	        this.off_urls = source["off_urls"];
	        this.on_pattern = source["on_pattern"];
	        this.off_pattern = source["off_pattern"];
	        this.insecure_tls = source["insecure_tls"];
	    }
	}
	export class StationRelay {
	    number: number;
	    label: string;
	    on: boolean;
	
	    static createFrom(source: any = {}) {
	        return new StationRelay(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.number = source["number"];
	        this.label = source["label"];
	        this.on = source["on"];
	    }
	}
	export class StationDeviceStatus {
	    id: string;
	    name: string;
	    type: string;
	    connected: boolean;
	    error?: string;
	    relays: StationRelay[];
	
	    static createFrom(source: any = {}) {
	        return new StationDeviceStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.type = source["type"];
	        this.connected = source["connected"];
	        this.error = source["error"];
	        this.relays = this.convertValues(source["relays"], StationRelay);
	    }
	
		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 StationInfoComputed {
	    country: string;
	    dxcc: number;
	    cqz: number;
	    ituz: number;
	    lat: number;
	    lon: number;
	
	    static createFrom(source: any = {}) {
	        return new StationInfoComputed(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.country = source["country"];
	        this.dxcc = source["dxcc"];
	        this.cqz = source["cqz"];
	        this.ituz = source["ituz"];
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	    }
	}
	
	export class StationSettings {
	    callsign: string;
	    operator: string;
	    my_grid: string;
	    my_country: string;
	    my_sota_ref: string;
	    my_pota_ref: string;
	    my_iota: string;
	
	    static createFrom(source: any = {}) {
	        return new StationSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.operator = source["operator"];
	        this.my_grid = source["my_grid"];
	        this.my_country = source["my_country"];
	        this.my_sota_ref = source["my_sota_ref"];
	        this.my_pota_ref = source["my_pota_ref"];
	        this.my_iota = source["my_iota"];
	    }
	}
	export class StationTestResult {
	    ok: boolean;
	    relays: number;
	    error?: string;
	
	    static createFrom(source: any = {}) {
	        return new StationTestResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ok = source["ok"];
	        this.relays = source["relays"];
	        this.error = source["error"];
	    }
	}
	export class TunerGeniusSettings {
	    enabled: boolean;
	    host: string;
	    password: string;
	
	    static createFrom(source: any = {}) {
	        return new TunerGeniusSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.host = source["host"];
	        this.password = source["password"];
	    }
	}
	export class ULSStatusResult {
	    count: number;
	    updated_at: string;
	    needs_refresh: boolean;
	
	    static createFrom(source: any = {}) {
	        return new ULSStatusResult(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.updated_at = source["updated_at"];
	        this.needs_refresh = source["needs_refresh"];
	    }
	}
	export class UltrabeamSettings {
	    enabled: boolean;
	    type: string;
	    transport: string;
	    host: string;
	    port: number;
	    com: string;
	    baud: number;
	    follow: boolean;
	    step_khz: number;
	    track_mode: string;
	    tx_inhibit: boolean;
	    bands: string[];
	    band_freqs: Record<string, number>;
	    freq_min_mhz: number;
	    freq_max_mhz: number;
	
	    static createFrom(source: any = {}) {
	        return new UltrabeamSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.type = source["type"];
	        this.transport = source["transport"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.com = source["com"];
	        this.baud = source["baud"];
	        this.follow = source["follow"];
	        this.step_khz = source["step_khz"];
	        this.track_mode = source["track_mode"];
	        this.tx_inhibit = source["tx_inhibit"];
	        this.bands = source["bands"];
	        this.band_freqs = source["band_freqs"];
	        this.freq_min_mhz = source["freq_min_mhz"];
	        this.freq_max_mhz = source["freq_max_mhz"];
	    }
	}
	export class UltrabeamStatusInfo {
	    enabled: boolean;
	    type: string;
	    connected: boolean;
	    direction: number;
	    frequency: number;
	    band: number;
	    moving: boolean;
	    elements: number[];
	    follow: boolean;
	    step_khz: number;
	    track_mode: string;
	    bands: string[];
	    band_freqs: Record<string, number>;
	
	    static createFrom(source: any = {}) {
	        return new UltrabeamStatusInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.type = source["type"];
	        this.connected = source["connected"];
	        this.direction = source["direction"];
	        this.frequency = source["frequency"];
	        this.band = source["band"];
	        this.moving = source["moving"];
	        this.elements = source["elements"];
	        this.follow = source["follow"];
	        this.step_khz = source["step_khz"];
	        this.track_mode = source["track_mode"];
	        this.bands = source["bands"];
	        this.band_freqs = source["band_freqs"];
	    }
	}
	export class UpdateInfo {
	    current: string;
	    latest: string;
	    available: boolean;
	    url: string;
	    download_url: string;
	
	    static createFrom(source: any = {}) {
	        return new UpdateInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.current = source["current"];
	        this.latest = source["latest"];
	        this.available = source["available"];
	        this.url = source["url"];
	        this.download_url = source["download_url"];
	    }
	}
	export class WKMacro {
	    label: string;
	    text: string;
	
	    static createFrom(source: any = {}) {
	        return new WKMacro(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.label = source["label"];
	        this.text = source["text"];
	    }
	}
	export class WatchlistSlotQuery {
	    call: string;
	    band: string;
	    mode: string;
	    contest: boolean;
	
	    static createFrom(source: any = {}) {
	        return new WatchlistSlotQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.call = source["call"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.contest = source["contest"];
	    }
	}
	export class WebPublishStatus {
	    last_run: string;
	    last_err: string;
	
	    static createFrom(source: any = {}) {
	        return new WebPublishStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.last_run = source["last_run"];
	        this.last_err = source["last_err"];
	    }
	}
	export class WinkeyerSettings {
	    enabled: boolean;
	    port: string;
	    baud: number;
	    wpm: number;
	    weight: number;
	    lead_in_ms: number;
	    tail_ms: number;
	    ratio: number;
	    farnsworth: number;
	    sidetone_hz: number;
	    mode: string;
	    swap: boolean;
	    autospace: boolean;
	    use_ptt: boolean;
	    serial_echo: boolean;
	    type: string;
	    cw_key_line: string;
	    cw_invert: boolean;
	    engine: string;
	    esc_clears_call: boolean;
	    send_on_type: boolean;
	    esm: boolean;
	    macros: WKMacro[];
	
	    static createFrom(source: any = {}) {
	        return new WinkeyerSettings(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.port = source["port"];
	        this.baud = source["baud"];
	        this.wpm = source["wpm"];
	        this.weight = source["weight"];
	        this.lead_in_ms = source["lead_in_ms"];
	        this.tail_ms = source["tail_ms"];
	        this.ratio = source["ratio"];
	        this.farnsworth = source["farnsworth"];
	        this.sidetone_hz = source["sidetone_hz"];
	        this.mode = source["mode"];
	        this.swap = source["swap"];
	        this.autospace = source["autospace"];
	        this.use_ptt = source["use_ptt"];
	        this.serial_echo = source["serial_echo"];
	        this.type = source["type"];
	        this.cw_key_line = source["cw_key_line"];
	        this.cw_invert = source["cw_invert"];
	        this.engine = source["engine"];
	        this.esc_clears_call = source["esc_clears_call"];
	        this.send_on_type = source["send_on_type"];
	        this.esm = source["esm"];
	        this.macros = this.convertValues(source["macros"], WKMacro);
	    }
	
		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 WsjtHighlightColours {
	    watchlist: string;
	    new_dxcc: string;
	    new_band: string;
	    worked: string;
	
	    static createFrom(source: any = {}) {
	        return new WsjtHighlightColours(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.watchlist = source["watchlist"];
	        this.new_dxcc = source["new_dxcc"];
	        this.new_band = source["new_band"];
	        this.worked = source["worked"];
	    }
	}

}

export namespace netctl {
	
	export class Station {
	    callsign: string;
	    name?: string;
	    qth?: string;
	    country?: string;
	    dxcc?: number;
	    itu?: number;
	    cq?: number;
	    grid?: string;
	    address?: string;
	    state?: string;
	    cnty?: string;
	    cont?: string;
	    lat?: number;
	    lon?: number;
	    email?: string;
	    groups?: string;
	    sig?: string;
	    sig_info?: string;
	
	    static createFrom(source: any = {}) {
	        return new Station(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.name = source["name"];
	        this.qth = source["qth"];
	        this.country = source["country"];
	        this.dxcc = source["dxcc"];
	        this.itu = source["itu"];
	        this.cq = source["cq"];
	        this.grid = source["grid"];
	        this.address = source["address"];
	        this.state = source["state"];
	        this.cnty = source["cnty"];
	        this.cont = source["cont"];
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	        this.email = source["email"];
	        this.groups = source["groups"];
	        this.sig = source["sig"];
	        this.sig_info = source["sig_info"];
	    }
	}
	export class Net {
	    id: string;
	    name: string;
	    default_rst_sent?: string;
	    default_rst_rcvd?: string;
	    default_comment?: string;
	    stations?: Station[];
	
	    static createFrom(source: any = {}) {
	        return new Net(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.default_rst_sent = source["default_rst_sent"];
	        this.default_rst_rcvd = source["default_rst_rcvd"];
	        this.default_comment = source["default_comment"];
	        this.stations = this.convertValues(source["stations"], Station);
	    }
	
		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 operating {
	
	export class AntennaBand {
	    band: string;
	    is_default: boolean;
	
	    static createFrom(source: any = {}) {
	        return new AntennaBand(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.is_default = source["is_default"];
	    }
	}
	export class Antenna {
	    id: number;
	    station_id: number;
	    name: string;
	    sort_order: number;
	    bands: AntennaBand[];
	
	    static createFrom(source: any = {}) {
	        return new Antenna(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.station_id = source["station_id"];
	        this.name = source["name"];
	        this.sort_order = source["sort_order"];
	        this.bands = this.convertValues(source["bands"], AntennaBand);
	    }
	
		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 BandDefault {
	    station_id: number;
	    station_name: string;
	    antenna_id: number;
	    antenna_name: string;
	    tx_pwr?: number;
	
	    static createFrom(source: any = {}) {
	        return new BandDefault(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.station_id = source["station_id"];
	        this.station_name = source["station_name"];
	        this.antenna_id = source["antenna_id"];
	        this.antenna_name = source["antenna_name"];
	        this.tx_pwr = source["tx_pwr"];
	    }
	}
	export class Station {
	    id: number;
	    profile_id: number;
	    name: string;
	    tx_pwr?: number;
	    sort_order: number;
	    antennas?: Antenna[];
	
	    static createFrom(source: any = {}) {
	        return new Station(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.profile_id = source["profile_id"];
	        this.name = source["name"];
	        this.tx_pwr = source["tx_pwr"];
	        this.sort_order = source["sort_order"];
	        this.antennas = this.convertValues(source["antennas"], Antenna);
	    }
	
		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 powergenius {
	
	export class Status {
	    connected: boolean;
	    host?: string;
	    last_error?: string;
	    state?: string;
	    fan_mode?: string;
	    temperature: number;
	    operate: boolean;
	    fwd_w: number;
	    peak_w: number;
	    vswr: number;
	    id: number;
	    peak_id: number;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.host = source["host"];
	        this.last_error = source["last_error"];
	        this.state = source["state"];
	        this.fan_mode = source["fan_mode"];
	        this.temperature = source["temperature"];
	        this.operate = source["operate"];
	        this.fwd_w = source["fwd_w"];
	        this.peak_w = source["peak_w"];
	        this.vswr = source["vswr"];
	        this.id = source["id"];
	        this.peak_id = source["peak_id"];
	    }
	}

}

export namespace profile {
	
	export class ProfileDB {
	    backend: string;
	    host: string;
	    port: number;
	    user: string;
	    password: string;
	    database: string;
	    path?: string;
	
	    static createFrom(source: any = {}) {
	        return new ProfileDB(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.backend = source["backend"];
	        this.host = source["host"];
	        this.port = source["port"];
	        this.user = source["user"];
	        this.password = source["password"];
	        this.database = source["database"];
	        this.path = source["path"];
	    }
	}
	export class Profile {
	    id: number;
	    name: string;
	    callsign: string;
	    operator: string;
	    op_name: string;
	    owner_callsign: string;
	    my_grid: string;
	    my_country: string;
	    my_state: string;
	    my_cnty: string;
	    my_street: string;
	    my_city: string;
	    my_postal_code: string;
	    my_sota_ref: string;
	    my_iota: string;
	    my_pota_ref: string;
	    my_rig: string;
	    my_antenna: string;
	    my_dxcc?: number;
	    my_cqz?: number;
	    my_ituz?: number;
	    my_lat?: number;
	    my_lon?: number;
	    tx_pwr?: number;
	    is_active: boolean;
	    sort_order: number;
	    db: ProfileDB;
	    // Go type: time
	    created_at: any;
	    // Go type: time
	    updated_at: any;
	
	    static createFrom(source: any = {}) {
	        return new Profile(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.callsign = source["callsign"];
	        this.operator = source["operator"];
	        this.op_name = source["op_name"];
	        this.owner_callsign = source["owner_callsign"];
	        this.my_grid = source["my_grid"];
	        this.my_country = source["my_country"];
	        this.my_state = source["my_state"];
	        this.my_cnty = source["my_cnty"];
	        this.my_street = source["my_street"];
	        this.my_city = source["my_city"];
	        this.my_postal_code = source["my_postal_code"];
	        this.my_sota_ref = source["my_sota_ref"];
	        this.my_iota = source["my_iota"];
	        this.my_pota_ref = source["my_pota_ref"];
	        this.my_rig = source["my_rig"];
	        this.my_antenna = source["my_antenna"];
	        this.my_dxcc = source["my_dxcc"];
	        this.my_cqz = source["my_cqz"];
	        this.my_ituz = source["my_ituz"];
	        this.my_lat = source["my_lat"];
	        this.my_lon = source["my_lon"];
	        this.tx_pwr = source["tx_pwr"];
	        this.is_active = source["is_active"];
	        this.sort_order = source["sort_order"];
	        this.db = this.convertValues(source["db"], ProfileDB);
	        this.created_at = this.convertValues(source["created_at"], null);
	        this.updated_at = this.convertValues(source["updated_at"], null);
	    }
	
		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 pskr {
	
	export class Status {
	    running: boolean;
	    received: number;
	    // Go type: time
	    last_at: any;
	    last_err?: string;
	    broker: string;
	    bands: string[];
	    near_km: number;
	    squares: number;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.running = source["running"];
	        this.received = source["received"];
	        this.last_at = this.convertValues(source["last_at"], null);
	        this.last_err = source["last_err"];
	        this.broker = source["broker"];
	        this.bands = source["bands"];
	        this.near_km = source["near_km"];
	        this.squares = source["squares"];
	    }
	
		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 pskrtgt {
	
	export class Bin {
	    offset_hz: number;
	    count: number;
	    avg_snr: number;
	
	    static createFrom(source: any = {}) {
	        return new Bin(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.offset_hz = source["offset_hz"];
	        this.count = source["count"];
	        this.avg_snr = source["avg_snr"];
	    }
	}
	export class Entry {
	    call: string;
	    grid: string;
	    snr: number;
	    offset_hz: number;
	    age_sec: number;
	
	    static createFrom(source: any = {}) {
	        return new Entry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.call = source["call"];
	        this.grid = source["grid"];
	        this.snr = source["snr"];
	        this.offset_hz = source["offset_hz"];
	        this.age_sec = source["age_sec"];
	    }
	}
	export class Analysis {
	    target: string;
	    mode?: string;
	    enabled: boolean;
	    online: boolean;
	    spots: number;
	    he_me: boolean;
	    he_me_seconds: number;
	    he_me_snr: number;
	    he_me_offset_hz: number;
	    target_uploads: boolean;
	    target_grid?: string;
	    near_him_count: number;
	    near_him_top: Entry[];
	    from_my_area_count: number;
	    from_my_area_top: Entry[];
	    path_open: boolean;
	    heard_by_count: number;
	    heard_near_me: number;
	    heard_near_me_top: Entry[];
	    decoded_by_count: number;
	    decoded_by_top: Entry[];
	    decoded_by_calls: string[];
	    pileup_count: number;
	    dial_hz: number;
	    ceiling_hz: number;
	    decodes_in_window: number;
	    bins: Bin[];
	    suggested_offset: number;
	
	    static createFrom(source: any = {}) {
	        return new Analysis(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.target = source["target"];
	        this.mode = source["mode"];
	        this.enabled = source["enabled"];
	        this.online = source["online"];
	        this.spots = source["spots"];
	        this.he_me = source["he_me"];
	        this.he_me_seconds = source["he_me_seconds"];
	        this.he_me_snr = source["he_me_snr"];
	        this.he_me_offset_hz = source["he_me_offset_hz"];
	        this.target_uploads = source["target_uploads"];
	        this.target_grid = source["target_grid"];
	        this.near_him_count = source["near_him_count"];
	        this.near_him_top = this.convertValues(source["near_him_top"], Entry);
	        this.from_my_area_count = source["from_my_area_count"];
	        this.from_my_area_top = this.convertValues(source["from_my_area_top"], Entry);
	        this.path_open = source["path_open"];
	        this.heard_by_count = source["heard_by_count"];
	        this.heard_near_me = source["heard_near_me"];
	        this.heard_near_me_top = this.convertValues(source["heard_near_me_top"], Entry);
	        this.decoded_by_count = source["decoded_by_count"];
	        this.decoded_by_top = this.convertValues(source["decoded_by_top"], Entry);
	        this.decoded_by_calls = source["decoded_by_calls"];
	        this.pileup_count = source["pileup_count"];
	        this.dial_hz = source["dial_hz"];
	        this.ceiling_hz = source["ceiling_hz"];
	        this.decodes_in_window = source["decodes_in_window"];
	        this.bins = this.convertValues(source["bins"], Bin);
	        this.suggested_offset = source["suggested_offset"];
	    }
	
		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 psu {
	
	export class Status {
	    connected: boolean;
	    on: boolean;
	    volts: number;
	    amps: number;
	    watts: number;
	    set_volts: number;
	    set_amps: number;
	    protected: number;
	    error?: string;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.on = source["on"];
	        this.volts = source["volts"];
	        this.amps = source["amps"];
	        this.watts = source["watts"];
	        this.set_volts = source["set_volts"];
	        this.set_amps = source["set_amps"];
	        this.protected = source["protected"];
	        this.error = source["error"];
	    }
	}

}

export namespace qslcard {
	
	export class Bevel {
	    dx: number;
	    dy: number;
	    dark: string;
	    light: string;
	
	    static createFrom(source: any = {}) {
	        return new Bevel(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.dx = source["dx"];
	        this.dy = source["dy"];
	        this.dark = source["dark"];
	        this.light = source["light"];
	    }
	}
	export class FxParams {
	    plump?: number;
	    edge?: number;
	    outerw?: number;
	    gloss?: number;
	    gloss_h?: number;
	    gloss_i?: number;
	    inner_b?: number;
	    depth?: number;
	    angle?: number;
	    slant?: number;
	    grunge?: number;
	    bevel?: number;
	    seed?: number;
	    dark?: string;
	    outer?: string;
	
	    static createFrom(source: any = {}) {
	        return new FxParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.plump = source["plump"];
	        this.edge = source["edge"];
	        this.outerw = source["outerw"];
	        this.gloss = source["gloss"];
	        this.gloss_h = source["gloss_h"];
	        this.gloss_i = source["gloss_i"];
	        this.inner_b = source["inner_b"];
	        this.depth = source["depth"];
	        this.angle = source["angle"];
	        this.slant = source["slant"];
	        this.grunge = source["grunge"];
	        this.bevel = source["bevel"];
	        this.seed = source["seed"];
	        this.dark = source["dark"];
	        this.outer = source["outer"];
	    }
	}
	export class Halo {
	    color: string;
	    blur: number;
	    opacity: number;
	
	    static createFrom(source: any = {}) {
	        return new Halo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.color = source["color"];
	        this.blur = source["blur"];
	        this.opacity = source["opacity"];
	    }
	}
	export class ShadowFx {
	    dx: number;
	    dy: number;
	    blur: number;
	    color: string;
	    opacity: number;
	
	    static createFrom(source: any = {}) {
	        return new ShadowFx(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.dx = source["dx"];
	        this.dy = source["dy"];
	        this.blur = source["blur"];
	        this.color = source["color"];
	        this.opacity = source["opacity"];
	    }
	}
	export class Shine {
	    coverage: number;
	    opacity: number;
	
	    static createFrom(source: any = {}) {
	        return new Shine(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.coverage = source["coverage"];
	        this.opacity = source["opacity"];
	    }
	}
	export class StyleParams {
	    gradient?: string[];
	    shine?: Shine;
	    outline_color?: string;
	    outline_width?: number;
	    halo?: Halo;
	    shadow?: ShadowFx;
	    bevel_offset?: Bevel;
	    color?: string;
	    fx?: FxParams;
	
	    static createFrom(source: any = {}) {
	        return new StyleParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.gradient = source["gradient"];
	        this.shine = this.convertValues(source["shine"], Shine);
	        this.outline_color = source["outline_color"];
	        this.outline_width = source["outline_width"];
	        this.halo = this.convertValues(source["halo"], Halo);
	        this.shadow = this.convertValues(source["shadow"], ShadowFx);
	        this.bevel_offset = this.convertValues(source["bevel_offset"], Bevel);
	        this.color = source["color"];
	        this.fx = this.convertValues(source["fx"], FxParams);
	    }
	
		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 qso {
	
	export class BandCategory {
	    band: string;
	    cw: number;
	    phone: number;
	    data: number;
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new BandCategory(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.cw = source["cw"];
	        this.phone = source["phone"];
	        this.data = source["data"];
	        this.total = source["total"];
	    }
	}
	export class BandMode {
	    band: string;
	    mode: string;
	
	    static createFrom(source: any = {}) {
	        return new BandMode(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.mode = source["mode"];
	    }
	}
	export class BandStatus {
	    band: string;
	    class: string;
	    status: string;
	    call?: string;
	
	    static createFrom(source: any = {}) {
	        return new BandStatus(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.band = source["band"];
	        this.class = source["class"];
	        this.status = source["status"];
	        this.call = source["call"];
	    }
	}
	export class Bucket {
	    key: string;
	    count: number;
	
	    static createFrom(source: any = {}) {
	        return new Bucket(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.key = source["key"];
	        this.count = source["count"];
	    }
	}
	export class Condition {
	    field: string;
	    op: string;
	    value: string;
	
	    static createFrom(source: any = {}) {
	        return new Condition(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.field = source["field"];
	        this.op = source["op"];
	        this.value = source["value"];
	    }
	}
	export class ContestRun {
	    id: string;
	    year: number;
	    count: number;
	    start: string;
	    end: string;
	
	    static createFrom(source: any = {}) {
	        return new ContestRun(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.year = source["year"];
	        this.count = source["count"];
	        this.start = source["start"];
	        this.end = source["end"];
	    }
	}
	export class Gap {
	    start: string;
	    end: string;
	    minutes: number;
	
	    static createFrom(source: any = {}) {
	        return new Gap(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.start = source["start"];
	        this.end = source["end"];
	        this.minutes = source["minutes"];
	    }
	}
	export class GridSquare {
	    grid: string;
	    count: number;
	    confirmed: boolean;
	    band?: string;
	    mode?: string;
	
	    static createFrom(source: any = {}) {
	        return new GridSquare(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.grid = source["grid"];
	        this.count = source["count"];
	        this.confirmed = source["confirmed"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	    }
	}
	export class ListFilter {
	    callsign?: string;
	    band?: string;
	    mode?: string;
	    station_callsign?: string;
	    limit?: number;
	    offset?: number;
	
	    static createFrom(source: any = {}) {
	        return new ListFilter(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.station_callsign = source["station_callsign"];
	        this.limit = source["limit"];
	        this.offset = source["offset"];
	    }
	}
	export class QSO {
	    id: number;
	    number?: number;
	    callsign: string;
	    // Go type: time
	    qso_date: any;
	    // Go type: time
	    qso_date_off?: any;
	    band: string;
	    band_rx?: string;
	    mode: string;
	    submode?: string;
	    freq_hz?: number;
	    freq_rx_hz?: number;
	    rst_sent?: string;
	    rst_rcvd?: string;
	    name?: string;
	    qth?: string;
	    address?: string;
	    email?: string;
	    web?: string;
	    grid?: string;
	    gridsquare_ext?: string;
	    vucc_grids?: string;
	    country?: string;
	    state?: string;
	    cnty?: string;
	    dxcc?: number;
	    cont?: string;
	    cqz?: number;
	    ituz?: number;
	    iota?: string;
	    sota_ref?: string;
	    pota_ref?: string;
	    age?: number;
	    lat?: number;
	    lon?: number;
	    rig?: string;
	    ant?: string;
	    qsl_sent?: string;
	    qsl_rcvd?: string;
	    qsl_sent_date?: string;
	    qsl_rcvd_date?: string;
	    qsl_via?: string;
	    qsl_sent_via?: string;
	    qsl_rcvd_via?: string;
	    qsl_msg?: string;
	    qslmsg_rcvd?: string;
	    lotw_sent?: string;
	    lotw_rcvd?: string;
	    lotw_sent_date?: string;
	    lotw_rcvd_date?: string;
	    eqsl_sent?: string;
	    eqsl_rcvd?: string;
	    eqsl_sent_date?: string;
	    eqsl_rcvd_date?: string;
	    clublog_qso_upload_date?: string;
	    clublog_qso_upload_status?: string;
	    hrdlog_qso_upload_date?: string;
	    hrdlog_qso_upload_status?: string;
	    qrzcom_qso_upload_date?: string;
	    qrzcom_qso_upload_status?: string;
	    qrzcom_qso_download_date?: string;
	    qrzcom_qso_download_status?: string;
	    clublog_qso_download_date?: string;
	    clublog_qso_download_status?: string;
	    contest_id?: string;
	    srx?: number;
	    stx?: number;
	    srx_string?: string;
	    stx_string?: string;
	    check?: string;
	    precedence?: string;
	    arrl_sect?: string;
	    prop_mode?: string;
	    sat_name?: string;
	    sat_mode?: string;
	    ant_az?: number;
	    ant_el?: number;
	    ant_path?: string;
	    station_callsign?: string;
	    operator?: string;
	    my_grid?: string;
	    my_gridsquare_ext?: string;
	    my_country?: string;
	    my_state?: string;
	    my_cnty?: string;
	    my_iota?: string;
	    my_sota_ref?: string;
	    my_pota_ref?: string;
	    my_dxcc?: number;
	    my_cq_zone?: number;
	    my_itu_zone?: number;
	    my_lat?: number;
	    my_lon?: number;
	    my_street?: string;
	    my_city?: string;
	    my_postal_code?: string;
	    my_rig?: string;
	    my_antenna?: string;
	    tx_pwr?: number;
	    comment?: string;
	    notes?: string;
	    sig?: string;
	    sig_info?: string;
	    my_sig?: string;
	    my_sig_info?: string;
	    wwff_ref?: string;
	    my_wwff_ref?: string;
	    distance?: number;
	    rx_pwr?: number;
	    a_index?: number;
	    k_index?: number;
	    sfi?: number;
	    skcc?: string;
	    fists?: string;
	    ten_ten?: string;
	    contacted_op?: string;
	    eq_call?: string;
	    pfx?: string;
	    my_name?: string;
	    class?: string;
	    darc_dok?: string;
	    my_darc_dok?: string;
	    region?: string;
	    silent_key?: string;
	    swl?: string;
	    qso_complete?: string;
	    qso_random?: string;
	    credit_granted?: string;
	    credit_submitted?: string;
	    my_arrl_sect?: string;
	    my_vucc_grids?: string;
	    extras?: Record<string, string>;
	    award_refs?: string;
	    sync_uid?: string;
	    // Go type: time
	    created_at: any;
	    // Go type: time
	    updated_at: any;
	
	    static createFrom(source: any = {}) {
	        return new QSO(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.number = source["number"];
	        this.callsign = source["callsign"];
	        this.qso_date = this.convertValues(source["qso_date"], null);
	        this.qso_date_off = this.convertValues(source["qso_date_off"], null);
	        this.band = source["band"];
	        this.band_rx = source["band_rx"];
	        this.mode = source["mode"];
	        this.submode = source["submode"];
	        this.freq_hz = source["freq_hz"];
	        this.freq_rx_hz = source["freq_rx_hz"];
	        this.rst_sent = source["rst_sent"];
	        this.rst_rcvd = source["rst_rcvd"];
	        this.name = source["name"];
	        this.qth = source["qth"];
	        this.address = source["address"];
	        this.email = source["email"];
	        this.web = source["web"];
	        this.grid = source["grid"];
	        this.gridsquare_ext = source["gridsquare_ext"];
	        this.vucc_grids = source["vucc_grids"];
	        this.country = source["country"];
	        this.state = source["state"];
	        this.cnty = source["cnty"];
	        this.dxcc = source["dxcc"];
	        this.cont = source["cont"];
	        this.cqz = source["cqz"];
	        this.ituz = source["ituz"];
	        this.iota = source["iota"];
	        this.sota_ref = source["sota_ref"];
	        this.pota_ref = source["pota_ref"];
	        this.age = source["age"];
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	        this.rig = source["rig"];
	        this.ant = source["ant"];
	        this.qsl_sent = source["qsl_sent"];
	        this.qsl_rcvd = source["qsl_rcvd"];
	        this.qsl_sent_date = source["qsl_sent_date"];
	        this.qsl_rcvd_date = source["qsl_rcvd_date"];
	        this.qsl_via = source["qsl_via"];
	        this.qsl_sent_via = source["qsl_sent_via"];
	        this.qsl_rcvd_via = source["qsl_rcvd_via"];
	        this.qsl_msg = source["qsl_msg"];
	        this.qslmsg_rcvd = source["qslmsg_rcvd"];
	        this.lotw_sent = source["lotw_sent"];
	        this.lotw_rcvd = source["lotw_rcvd"];
	        this.lotw_sent_date = source["lotw_sent_date"];
	        this.lotw_rcvd_date = source["lotw_rcvd_date"];
	        this.eqsl_sent = source["eqsl_sent"];
	        this.eqsl_rcvd = source["eqsl_rcvd"];
	        this.eqsl_sent_date = source["eqsl_sent_date"];
	        this.eqsl_rcvd_date = source["eqsl_rcvd_date"];
	        this.clublog_qso_upload_date = source["clublog_qso_upload_date"];
	        this.clublog_qso_upload_status = source["clublog_qso_upload_status"];
	        this.hrdlog_qso_upload_date = source["hrdlog_qso_upload_date"];
	        this.hrdlog_qso_upload_status = source["hrdlog_qso_upload_status"];
	        this.qrzcom_qso_upload_date = source["qrzcom_qso_upload_date"];
	        this.qrzcom_qso_upload_status = source["qrzcom_qso_upload_status"];
	        this.qrzcom_qso_download_date = source["qrzcom_qso_download_date"];
	        this.qrzcom_qso_download_status = source["qrzcom_qso_download_status"];
	        this.clublog_qso_download_date = source["clublog_qso_download_date"];
	        this.clublog_qso_download_status = source["clublog_qso_download_status"];
	        this.contest_id = source["contest_id"];
	        this.srx = source["srx"];
	        this.stx = source["stx"];
	        this.srx_string = source["srx_string"];
	        this.stx_string = source["stx_string"];
	        this.check = source["check"];
	        this.precedence = source["precedence"];
	        this.arrl_sect = source["arrl_sect"];
	        this.prop_mode = source["prop_mode"];
	        this.sat_name = source["sat_name"];
	        this.sat_mode = source["sat_mode"];
	        this.ant_az = source["ant_az"];
	        this.ant_el = source["ant_el"];
	        this.ant_path = source["ant_path"];
	        this.station_callsign = source["station_callsign"];
	        this.operator = source["operator"];
	        this.my_grid = source["my_grid"];
	        this.my_gridsquare_ext = source["my_gridsquare_ext"];
	        this.my_country = source["my_country"];
	        this.my_state = source["my_state"];
	        this.my_cnty = source["my_cnty"];
	        this.my_iota = source["my_iota"];
	        this.my_sota_ref = source["my_sota_ref"];
	        this.my_pota_ref = source["my_pota_ref"];
	        this.my_dxcc = source["my_dxcc"];
	        this.my_cq_zone = source["my_cq_zone"];
	        this.my_itu_zone = source["my_itu_zone"];
	        this.my_lat = source["my_lat"];
	        this.my_lon = source["my_lon"];
	        this.my_street = source["my_street"];
	        this.my_city = source["my_city"];
	        this.my_postal_code = source["my_postal_code"];
	        this.my_rig = source["my_rig"];
	        this.my_antenna = source["my_antenna"];
	        this.tx_pwr = source["tx_pwr"];
	        this.comment = source["comment"];
	        this.notes = source["notes"];
	        this.sig = source["sig"];
	        this.sig_info = source["sig_info"];
	        this.my_sig = source["my_sig"];
	        this.my_sig_info = source["my_sig_info"];
	        this.wwff_ref = source["wwff_ref"];
	        this.my_wwff_ref = source["my_wwff_ref"];
	        this.distance = source["distance"];
	        this.rx_pwr = source["rx_pwr"];
	        this.a_index = source["a_index"];
	        this.k_index = source["k_index"];
	        this.sfi = source["sfi"];
	        this.skcc = source["skcc"];
	        this.fists = source["fists"];
	        this.ten_ten = source["ten_ten"];
	        this.contacted_op = source["contacted_op"];
	        this.eq_call = source["eq_call"];
	        this.pfx = source["pfx"];
	        this.my_name = source["my_name"];
	        this.class = source["class"];
	        this.darc_dok = source["darc_dok"];
	        this.my_darc_dok = source["my_darc_dok"];
	        this.region = source["region"];
	        this.silent_key = source["silent_key"];
	        this.swl = source["swl"];
	        this.qso_complete = source["qso_complete"];
	        this.qso_random = source["qso_random"];
	        this.credit_granted = source["credit_granted"];
	        this.credit_submitted = source["credit_submitted"];
	        this.my_arrl_sect = source["my_arrl_sect"];
	        this.my_vucc_grids = source["my_vucc_grids"];
	        this.extras = source["extras"];
	        this.award_refs = source["award_refs"];
	        this.sync_uid = source["sync_uid"];
	        this.created_at = this.convertValues(source["created_at"], null);
	        this.updated_at = this.convertValues(source["updated_at"], null);
	    }
	
		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 QueryFilter {
	    quick_callsign?: string;
	    conditions?: Condition[];
	    match?: string;
	    limit?: number;
	    offset?: number;
	
	    static createFrom(source: any = {}) {
	        return new QueryFilter(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.quick_callsign = source["quick_callsign"];
	        this.conditions = this.convertValues(source["conditions"], Condition);
	        this.match = source["match"];
	        this.limit = source["limit"];
	        this.offset = source["offset"];
	    }
	
		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 SlotStats {
	    slots_worked: number;
	    slots_confirmed: number;
	    dxcc_worked: number;
	    dxcc_confirmed: number;
	    ph_worked: number;
	    ph_confirmed: number;
	    cw_worked: number;
	    cw_confirmed: number;
	    dig_worked: number;
	    dig_confirmed: number;
	
	    static createFrom(source: any = {}) {
	        return new SlotStats(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.slots_worked = source["slots_worked"];
	        this.slots_confirmed = source["slots_confirmed"];
	        this.dxcc_worked = source["dxcc_worked"];
	        this.dxcc_confirmed = source["dxcc_confirmed"];
	        this.ph_worked = source["ph_worked"];
	        this.ph_confirmed = source["ph_confirmed"];
	        this.cw_worked = source["cw_worked"];
	        this.cw_confirmed = source["cw_confirmed"];
	        this.dig_worked = source["dig_worked"];
	        this.dig_confirmed = source["dig_confirmed"];
	    }
	}
	export class Stats {
	    total: number;
	    unique_calls: number;
	    entities: number;
	    continents: number;
	    first_qso: string;
	    last_qso: string;
	    last_new_dxcc: string;
	    last_new_dxcc_num: number;
	    last_new_dxcc_call: string;
	    last_new_dxcc_date: string;
	    confirmed_lotw: number;
	    confirmed_eqsl: number;
	    confirmed_qsl: number;
	    confirmed_any: number;
	    by_mode: Bucket[];
	    by_band: Bucket[];
	    by_band_category: BandCategory[];
	    by_operator: Bucket[];
	    by_station: Bucket[];
	    by_continent: Bucket[];
	    top_entities: Bucket[];
	    by_year: Bucket[];
	    by_month: Bucket[];
	    by_hour: Bucket[];
	    by_day7: Bucket[];
	    by_day30: Bucket[];
	    by_month12: Bucket[];
	    by_day_win: Bucket[];
	    by_week_win: Bucket[];
	    by_month_win: Bucket[];
	    by_year_win: Bucket[];
	    by_hour_of_day: Bucket[];
	    by_weekday: Bucket[];
	    window_start: string;
	    window_end: string;
	    window_hours: number;
	    avg_per_hour: number;
	    avg_per_active: number;
	    on_air_minutes: number;
	    off_air_minutes: number;
	    peak_hour_key: string;
	    peak_hour_count: number;
	    best_60: number;
	    gaps: Gap[];
	    rate: Bucket[];
	    rate_ops: string[];
	    rate_by_op: number[][];
	
	    static createFrom(source: any = {}) {
	        return new Stats(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.unique_calls = source["unique_calls"];
	        this.entities = source["entities"];
	        this.continents = source["continents"];
	        this.first_qso = source["first_qso"];
	        this.last_qso = source["last_qso"];
	        this.last_new_dxcc = source["last_new_dxcc"];
	        this.last_new_dxcc_num = source["last_new_dxcc_num"];
	        this.last_new_dxcc_call = source["last_new_dxcc_call"];
	        this.last_new_dxcc_date = source["last_new_dxcc_date"];
	        this.confirmed_lotw = source["confirmed_lotw"];
	        this.confirmed_eqsl = source["confirmed_eqsl"];
	        this.confirmed_qsl = source["confirmed_qsl"];
	        this.confirmed_any = source["confirmed_any"];
	        this.by_mode = this.convertValues(source["by_mode"], Bucket);
	        this.by_band = this.convertValues(source["by_band"], Bucket);
	        this.by_band_category = this.convertValues(source["by_band_category"], BandCategory);
	        this.by_operator = this.convertValues(source["by_operator"], Bucket);
	        this.by_station = this.convertValues(source["by_station"], Bucket);
	        this.by_continent = this.convertValues(source["by_continent"], Bucket);
	        this.top_entities = this.convertValues(source["top_entities"], Bucket);
	        this.by_year = this.convertValues(source["by_year"], Bucket);
	        this.by_month = this.convertValues(source["by_month"], Bucket);
	        this.by_hour = this.convertValues(source["by_hour"], Bucket);
	        this.by_day7 = this.convertValues(source["by_day7"], Bucket);
	        this.by_day30 = this.convertValues(source["by_day30"], Bucket);
	        this.by_month12 = this.convertValues(source["by_month12"], Bucket);
	        this.by_day_win = this.convertValues(source["by_day_win"], Bucket);
	        this.by_week_win = this.convertValues(source["by_week_win"], Bucket);
	        this.by_month_win = this.convertValues(source["by_month_win"], Bucket);
	        this.by_year_win = this.convertValues(source["by_year_win"], Bucket);
	        this.by_hour_of_day = this.convertValues(source["by_hour_of_day"], Bucket);
	        this.by_weekday = this.convertValues(source["by_weekday"], Bucket);
	        this.window_start = source["window_start"];
	        this.window_end = source["window_end"];
	        this.window_hours = source["window_hours"];
	        this.avg_per_hour = source["avg_per_hour"];
	        this.avg_per_active = source["avg_per_active"];
	        this.on_air_minutes = source["on_air_minutes"];
	        this.off_air_minutes = source["off_air_minutes"];
	        this.peak_hour_key = source["peak_hour_key"];
	        this.peak_hour_count = source["peak_hour_count"];
	        this.best_60 = source["best_60"];
	        this.gaps = this.convertValues(source["gaps"], Gap);
	        this.rate = this.convertValues(source["rate"], Bucket);
	        this.rate_ops = source["rate_ops"];
	        this.rate_by_op = source["rate_by_op"];
	    }
	
		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 WorkedBefore {
	    callsign: string;
	    count: number;
	    // Go type: time
	    first?: any;
	    // Go type: time
	    last?: any;
	    bands: string[];
	    modes: string[];
	    band_modes: BandMode[];
	    entries: QSO[];
	    dxcc?: number;
	    dxcc_name?: string;
	    dxcc_count: number;
	    // Go type: time
	    dxcc_first?: any;
	    // Go type: time
	    dxcc_last?: any;
	    dxcc_bands: string[];
	    dxcc_modes: string[];
	    dxcc_band_modes: BandMode[];
	    mw_rank?: number;
	    band_status: BandStatus[];
	
	    static createFrom(source: any = {}) {
	        return new WorkedBefore(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.count = source["count"];
	        this.first = this.convertValues(source["first"], null);
	        this.last = this.convertValues(source["last"], null);
	        this.bands = source["bands"];
	        this.modes = source["modes"];
	        this.band_modes = this.convertValues(source["band_modes"], BandMode);
	        this.entries = this.convertValues(source["entries"], QSO);
	        this.dxcc = source["dxcc"];
	        this.dxcc_name = source["dxcc_name"];
	        this.dxcc_count = source["dxcc_count"];
	        this.dxcc_first = this.convertValues(source["dxcc_first"], null);
	        this.dxcc_last = this.convertValues(source["dxcc_last"], null);
	        this.dxcc_bands = source["dxcc_bands"];
	        this.dxcc_modes = source["dxcc_modes"];
	        this.dxcc_band_modes = this.convertValues(source["dxcc_band_modes"], BandMode);
	        this.mw_rank = source["mw_rank"];
	        this.band_status = this.convertValues(source["band_status"], BandStatus);
	    }
	
		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 sat {
	
	export class Pass {
	    name: string;
	    // Go type: time
	    aos: any;
	    // Go type: time
	    los: any;
	    aos_az: number;
	    los_az: number;
	    max_el: number;
	    max_el_az: number;
	    // Go type: time
	    max_el_at: any;
	    duration_s: number;
	
	    static createFrom(source: any = {}) {
	        return new Pass(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.aos = this.convertValues(source["aos"], null);
	        this.los = this.convertValues(source["los"], null);
	        this.aos_az = source["aos_az"];
	        this.los_az = source["los_az"];
	        this.max_el = source["max_el"];
	        this.max_el_az = source["max_el_az"];
	        this.max_el_at = this.convertValues(source["max_el_at"], null);
	        this.duration_s = source["duration_s"];
	    }
	
		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 Position {
	    name: string;
	    // Go type: time
	    at: any;
	    lat: number;
	    lon: number;
	    alt_km: number;
	    footprint_km: number;
	    az: number;
	    el: number;
	    range_km: number;
	    range_rate: number;
	
	    static createFrom(source: any = {}) {
	        return new Position(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.at = this.convertValues(source["at"], null);
	        this.lat = source["lat"];
	        this.lon = source["lon"];
	        this.alt_km = source["alt_km"];
	        this.footprint_km = source["footprint_km"];
	        this.az = source["az"];
	        this.el = source["el"];
	        this.range_km = source["range_km"];
	        this.range_rate = source["range_rate"];
	    }
	
		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 scp {
	
	export class Result {
	    partial: string[];
	    nplus1: string[];
	
	    static createFrom(source: any = {}) {
	        return new Result(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.partial = source["partial"];
	        this.nplus1 = source["nplus1"];
	    }
	}

}

export namespace solar {
	
	export class Data {
	    sfi: string;
	    ssn: string;
	    a_index: string;
	    k_index: string;
	    xray: string;
	    geomag_field: string;
	    aurora: string;
	    muf: string;
	    updated: string;
	    source: string;
	    ok: boolean;
	    error?: string;
	    // Go type: time
	    fetched_at: any;
	
	    static createFrom(source: any = {}) {
	        return new Data(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.sfi = source["sfi"];
	        this.ssn = source["ssn"];
	        this.a_index = source["a_index"];
	        this.k_index = source["k_index"];
	        this.xray = source["xray"];
	        this.geomag_field = source["geomag_field"];
	        this.aurora = source["aurora"];
	        this.muf = source["muf"];
	        this.updated = source["updated"];
	        this.source = source["source"];
	        this.ok = source["ok"];
	        this.error = source["error"];
	        this.fetched_at = this.convertValues(source["fetched_at"], null);
	    }
	
		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 spe {
	
	export class Status {
	    connected: boolean;
	    transport: string;
	    last_error?: string;
	    model?: string;
	    operate: boolean;
	    tx: boolean;
	    input?: string;
	    band?: string;
	    power_level?: string;
	    output_w: number;
	    swr_atu: number;
	    swr_ant: number;
	    volt_pa: number;
	    curr_pa: number;
	    temp_c: number;
	    warnings?: string;
	    alarms?: string;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.transport = source["transport"];
	        this.last_error = source["last_error"];
	        this.model = source["model"];
	        this.operate = source["operate"];
	        this.tx = source["tx"];
	        this.input = source["input"];
	        this.band = source["band"];
	        this.power_level = source["power_level"];
	        this.output_w = source["output_w"];
	        this.swr_atu = source["swr_atu"];
	        this.swr_ant = source["swr_ant"];
	        this.volt_pa = source["volt_pa"];
	        this.curr_pa = source["curr_pa"];
	        this.temp_c = source["temp_c"];
	        this.warnings = source["warnings"];
	        this.alarms = source["alarms"];
	    }
	}

}

export namespace tunergenius {
	
	export class Channel {
	    ptt: boolean;
	    band: number;
	    mode: number;
	    mode_str: string;
	    flex: string;
	    freq_mhz: number;
	    bypass: boolean;
	    antenna: number;
	
	    static createFrom(source: any = {}) {
	        return new Channel(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ptt = source["ptt"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.mode_str = source["mode_str"];
	        this.flex = source["flex"];
	        this.freq_mhz = source["freq_mhz"];
	        this.bypass = source["bypass"];
	        this.antenna = source["antenna"];
	    }
	}
	export class Status {
	    connected: boolean;
	    host?: string;
	    last_error?: string;
	    fwd_dbm: number;
	    fwd_w: number;
	    peak_w: number;
	    swr_db: number;
	    vswr: number;
	    operate: boolean;
	    bypass: boolean;
	    tuning: boolean;
	    active: number;
	    three_way: boolean;
	    a: Channel;
	    b: Channel;
	    relay_c1: number;
	    relay_l: number;
	    relay_c2: number;
	    freq_mhz: number;
	    antenna: number;
	    message?: string;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.host = source["host"];
	        this.last_error = source["last_error"];
	        this.fwd_dbm = source["fwd_dbm"];
	        this.fwd_w = source["fwd_w"];
	        this.peak_w = source["peak_w"];
	        this.swr_db = source["swr_db"];
	        this.vswr = source["vswr"];
	        this.operate = source["operate"];
	        this.bypass = source["bypass"];
	        this.tuning = source["tuning"];
	        this.active = source["active"];
	        this.three_way = source["three_way"];
	        this.a = this.convertValues(source["a"], Channel);
	        this.b = this.convertValues(source["b"], Channel);
	        this.relay_c1 = source["relay_c1"];
	        this.relay_l = source["relay_l"];
	        this.relay_c2 = source["relay_c2"];
	        this.freq_mhz = source["freq_mhz"];
	        this.antenna = source["antenna"];
	        this.message = source["message"];
	    }
	
		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 udp {
	
	export class Config {
	    id: number;
	    direction: string;
	    name: string;
	    port: number;
	    service_type: string;
	    multicast: boolean;
	    multicast_group: string;
	    destination_ip: string;
	    enabled: boolean;
	    sort_order: number;
	    trigger: string;
	    template: string;
	    transport: string;
	    url: string;
	    line_end: string;
	
	    static createFrom(source: any = {}) {
	        return new Config(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.direction = source["direction"];
	        this.name = source["name"];
	        this.port = source["port"];
	        this.service_type = source["service_type"];
	        this.multicast = source["multicast"];
	        this.multicast_group = source["multicast_group"];
	        this.destination_ip = source["destination_ip"];
	        this.enabled = source["enabled"];
	        this.sort_order = source["sort_order"];
	        this.trigger = source["trigger"];
	        this.template = source["template"];
	        this.transport = source["transport"];
	        this.url = source["url"];
	        this.line_end = source["line_end"];
	    }
	}

}

export namespace watchlist {
	
	export class Entry {
	    callsign: string;
	    // Go type: time
	    lastSeen: any;
	    lastSeenStr: string;
	    // Go type: time
	    addedAt: any;
	    spotCount: number;
	    isContest: boolean;
	    notify: boolean;
	    isExpedition: boolean;
	    clubLogQSOs24h: number;
	    clubLogTotalQSOs: number;
	    clubLogHasOQRS: boolean;
	    clubLogLiveStream: boolean;
	    // Go type: time
	    clubLogUpdatedAt?: any;
	
	    static createFrom(source: any = {}) {
	        return new Entry(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.callsign = source["callsign"];
	        this.lastSeen = this.convertValues(source["lastSeen"], null);
	        this.lastSeenStr = source["lastSeenStr"];
	        this.addedAt = this.convertValues(source["addedAt"], null);
	        this.spotCount = source["spotCount"];
	        this.isContest = source["isContest"];
	        this.notify = source["notify"];
	        this.isExpedition = source["isExpedition"];
	        this.clubLogQSOs24h = source["clubLogQSOs24h"];
	        this.clubLogTotalQSOs = source["clubLogTotalQSOs"];
	        this.clubLogHasOQRS = source["clubLogHasOQRS"];
	        this.clubLogLiveStream = source["clubLogLiveStream"];
	        this.clubLogUpdatedAt = this.convertValues(source["clubLogUpdatedAt"], null);
	    }
	
		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 webpub {
	
	export class Config {
	    enabled: boolean;
	    format: string;
	    folder: string;
	    file_name: string;
	    title: string;
	    count: number;
	    interval_min: number;
	    columns: string[];
	    ftp_enabled: boolean;
	    ftp_host: string;
	    ftp_port: number;
	    ftp_user: string;
	    ftp_password: string;
	    ftp_tls: boolean;
	    ftp_folder: string;
	    ftp_file_name: string;
	
	    static createFrom(source: any = {}) {
	        return new Config(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.enabled = source["enabled"];
	        this.format = source["format"];
	        this.folder = source["folder"];
	        this.file_name = source["file_name"];
	        this.title = source["title"];
	        this.count = source["count"];
	        this.interval_min = source["interval_min"];
	        this.columns = source["columns"];
	        this.ftp_enabled = source["ftp_enabled"];
	        this.ftp_host = source["ftp_host"];
	        this.ftp_port = source["ftp_port"];
	        this.ftp_user = source["ftp_user"];
	        this.ftp_password = source["ftp_password"];
	        this.ftp_tls = source["ftp_tls"];
	        this.ftp_folder = source["ftp_folder"];
	        this.ftp_file_name = source["ftp_file_name"];
	    }
	}

}

export namespace winkeyer {
	
	export class Status {
	    connected: boolean;
	    busy: boolean;
	    wpm: number;
	    version: number;
	    port: string;
	    error?: string;
	
	    static createFrom(source: any = {}) {
	        return new Status(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.connected = source["connected"];
	        this.busy = source["busy"];
	        this.wpm = source["wpm"];
	        this.version = source["version"];
	        this.port = source["port"];
	        this.error = source["error"];
	    }
	}

}

