1885 lines
54 KiB
TypeScript
1885 lines
54 KiB
TypeScript
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 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[];
|
|
|
|
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"];
|
|
}
|
|
}
|
|
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 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 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 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;
|
|
|
|
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 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;
|
|
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.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"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|