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 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 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;
	    type?: string;
	    field: string;
	    match_by?: string;
	    exact_match?: boolean;
	    pattern: string;
	    leading_str?: string;
	    trailing_str?: string;
	    multi?: boolean;
	    dynamic?: boolean;
	    add_prefixes?: string[];
	    dxcc_filter: number[];
	    valid_bands?: string[];
	    valid_modes?: string[];
	    emission?: string[];
	    confirm: string[];
	    validate?: string[];
	    grant_codes?: string;
	    export_credit_granted?: boolean;
	    total: number;
	    builtin: 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.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.multi = source["multi"];
	        this.dynamic = source["dynamic"];
	        this.add_prefixes = source["add_prefixes"];
	        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.grant_codes = source["grant_codes"];
	        this.export_credit_granted = source["export_credit_granted"];
	        this.total = source["total"];
	        this.builtin = source["builtin"];
	    }
	}
	export class Ref {
	    ref: string;
	    name?: string;
	    group?: string;
	    subgrp?: string;
	    worked: boolean;
	    confirmed: boolean;
	    validated: boolean;
	    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.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 cat {
	
	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 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 extsvc {
	
	export class ServiceConfig {
	    api_key: string;
	    email: string;
	    username: string;
	    password: string;
	    callsign: string;
	    force_station_callsign: string;
	    tqsl_path: string;
	    station_location: string;
	    key_password: string;
	    upload_flag: string;
	    write_log: boolean;
	    auto_upload: 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.email = source["email"];
	        this.username = source["username"];
	        this.password = source["password"];
	        this.callsign = source["callsign"];
	        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_flag = source["upload_flag"];
	        this.write_log = source["write_log"];
	        this.auto_upload = source["auto_upload"];
	        this.upload_mode = source["upload_mode"];
	    }
	}
	export class ExternalServices {
	    qrz: ServiceConfig;
	    clublog: ServiceConfig;
	    lotw: ServiceConfig;
	
	    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);
	    }
	
		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 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;
	    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.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 main {
	
	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;
	    format: string;
	    from_gain: number;
	    mic_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.format = source["format"];
	        this.from_gain = source["from_gain"];
	        this.mic_gain = source["mic_gain"];
	    }
	}
	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 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 BackupSettings {
	    enabled: boolean;
	    folder: string;
	    rotation: number;
	    zip: 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.last_backup_at = source["last_backup_at"];
	        this.default_folder = source["default_folder"];
	    }
	}
	export class CATSettings {
	    enabled: boolean;
	    backend: string;
	    omnirig_rig: number;
	    poll_ms: number;
	    delay_ms: number;
	    digital_default: string;
	
	    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.poll_ms = source["poll_ms"];
	        this.delay_ms = source["delay_ms"];
	        this.digital_default = source["digital_default"];
	    }
	}
	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 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 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 DatabaseSettings {
	    path: string;
	    default_path: string;
	    is_custom: boolean;
	
	    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"];
	    }
	}
	export class EmailSettings {
	    enabled: boolean;
	    smtp_host: string;
	    smtp_port: number;
	    smtp_user: string;
	    smtp_password: string;
	    from: 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.encryption = source["encryption"];
	        this.auth = source["auth"];
	        this.auto_send = source["auto_send"];
	        this.subject = source["subject"];
	        this.body = source["body"];
	    }
	}
	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[];
	
	    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"];
	    }
	
		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 LookupSettings {
	    qrz_user: string;
	    qrz_password: string;
	    hamqth_user: string;
	    hamqth_password: string;
	    primary: string;
	    failsafe: string;
	    download_images: 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.cache_ttl_days = source["cache_ttl_days"];
	    }
	}
	
	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[];
	
	    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);
	    }
	
		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 QSLBulkUpdate {
	    sent_status: string;
	    rcvd_status: string;
	    sent_date: string;
	    rcvd_date: string;
	    via: 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"];
	    }
	}
	export class QSLDefaults {
	    qsl_sent: string;
	    qsl_rcvd: string;
	    lotw_sent: string;
	    lotw_rcvd: string;
	    eqsl_sent: string;
	    eqsl_rcvd: string;
	    clublog_status: string;
	    hrdlog_status: string;
	    qrzcom_status: string;
	    qrzcom_confirmed: 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.hrdlog_status = source["hrdlog_status"];
	        this.qrzcom_status = source["qrzcom_status"];
	        this.qrzcom_confirmed = source["qrzcom_confirmed"];
	    }
	}
	export class QSOAwardRef {
	    code: string;
	    ref: string;
	    name?: string;
	    pickable: 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"];
	    }
	}
	export class RotatorHeading {
	    enabled: boolean;
	    ok: boolean;
	    azimuth: number;
	    raw: string;
	
	    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"];
	    }
	}
	export class RotatorSettings {
	    enabled: boolean;
	    host: string;
	    port: number;
	    has_elevation: boolean;
	
	    static createFrom(source: any = {}) {
	        return new RotatorSettings(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.has_elevation = source["has_elevation"];
	    }
	}
	export class SpotQuery {
	    call: string;
	    band: string;
	    mode: 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"];
	    }
	}
	export class SpotStatus {
	    call: string;
	    band: string;
	    mode: string;
	    country?: string;
	    continent?: string;
	    status: string;
	    worked_call: 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"];
	    }
	}
	export class StartupStatus {
	    ok: boolean;
	    err: string;
	    db_path: string;
	    migrated_from_app_data: boolean;
	
	    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"];
	        this.migrated_from_app_data = source["migrated_from_app_data"];
	    }
	}
	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;
	
	    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"];
	    }
	}
	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 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;
	    engine: string;
	    esc_clears_call: boolean;
	    send_on_type: 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.engine = source["engine"];
	        this.esc_clears_call = source["esc_clears_call"];
	        this.send_on_type = source["send_on_type"];
	        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 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 profile {
	
	export class Profile {
	    id: number;
	    name: string;
	    callsign: string;
	    operator: 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_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;
	    // 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.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_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.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 qso {
	
	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;
	
	    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"];
	    }
	}
	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 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;
	    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_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;
	    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>;
	    // 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.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_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.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.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 UploadRow {
	    id: number;
	    qso_date: string;
	    callsign: string;
	    band: string;
	    mode: string;
	    country: string;
	    status: string;
	
	    static createFrom(source: any = {}) {
	        return new UploadRow(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.qso_date = source["qso_date"];
	        this.callsign = source["callsign"];
	        this.band = source["band"];
	        this.mode = source["mode"];
	        this.country = source["country"];
	        this.status = source["status"];
	    }
	}
	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[];
	    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.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 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;
	
	    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"];
	    }
	}

}

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

}