rouggy
9033e8518c
Embeds changelog.json (per-version EN + FR notes, curated from the release's commits). GetWhatsNew compares the stored last-seen version with the running build and returns the notes for every newer version, once, then advances the marker. A dialog shows them in the UI language on the first launch after update. Seeded with the 0.20.5 notes.
4268 lines
122 KiB
TypeScript
4268 lines
122 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 FieldDef {
|
|
name: string;
|
|
kind: string;
|
|
category: string;
|
|
promoted: boolean;
|
|
deprecated: boolean;
|
|
intl: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FieldDef(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.name = source["name"];
|
|
this.kind = source["kind"];
|
|
this.category = source["category"];
|
|
this.promoted = source["promoted"];
|
|
this.deprecated = source["deprecated"];
|
|
this.intl = source["intl"];
|
|
}
|
|
}
|
|
export class ImportResult {
|
|
total: number;
|
|
imported: number;
|
|
updated: number;
|
|
skipped: number;
|
|
duplicates: number;
|
|
duplicate_samples: string[];
|
|
errors: string[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ImportResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.total = source["total"];
|
|
this.imported = source["imported"];
|
|
this.updated = source["updated"];
|
|
this.skipped = source["skipped"];
|
|
this.duplicates = source["duplicates"];
|
|
this.duplicate_samples = source["duplicate_samples"];
|
|
this.errors = source["errors"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace alerts {
|
|
|
|
export class Rule {
|
|
id: string;
|
|
name: string;
|
|
enabled: boolean;
|
|
calls?: string[];
|
|
countries?: string[];
|
|
continents?: string[];
|
|
bands?: string[];
|
|
modes?: string[];
|
|
spotter_call?: string;
|
|
spotter_continents?: string[];
|
|
spotter_countries?: string[];
|
|
sound: boolean;
|
|
visual: boolean;
|
|
email: boolean;
|
|
again_after_min: number;
|
|
skip_worked: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Rule(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.enabled = source["enabled"];
|
|
this.calls = source["calls"];
|
|
this.countries = source["countries"];
|
|
this.continents = source["continents"];
|
|
this.bands = source["bands"];
|
|
this.modes = source["modes"];
|
|
this.spotter_call = source["spotter_call"];
|
|
this.spotter_continents = source["spotter_continents"];
|
|
this.spotter_countries = source["spotter_countries"];
|
|
this.sound = source["sound"];
|
|
this.visual = source["visual"];
|
|
this.email = source["email"];
|
|
this.again_after_min = source["again_after_min"];
|
|
this.skip_worked = source["skip_worked"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace antgenius {
|
|
|
|
export class Antenna {
|
|
index: number;
|
|
name: string;
|
|
bands: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Antenna(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.index = source["index"];
|
|
this.name = source["name"];
|
|
this.bands = source["bands"];
|
|
}
|
|
}
|
|
export class Status {
|
|
connected: boolean;
|
|
host?: string;
|
|
last_error?: string;
|
|
port_a: number;
|
|
port_b: number;
|
|
tx_a: boolean;
|
|
tx_b: boolean;
|
|
antennas: Antenna[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Status(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.connected = source["connected"];
|
|
this.host = source["host"];
|
|
this.last_error = source["last_error"];
|
|
this.port_a = source["port_a"];
|
|
this.port_b = source["port_b"];
|
|
this.tx_a = source["tx_a"];
|
|
this.tx_b = source["tx_b"];
|
|
this.antennas = this.convertValues(source["antennas"], Antenna);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace audio {
|
|
|
|
export class Device {
|
|
id: string;
|
|
name: string;
|
|
default: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Device(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.default = source["default"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace award {
|
|
|
|
export class BandCount {
|
|
band: string;
|
|
worked: number;
|
|
confirmed: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new BandCount(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.band = source["band"];
|
|
this.worked = source["worked"];
|
|
this.confirmed = source["confirmed"];
|
|
}
|
|
}
|
|
export class OrRule {
|
|
field: string;
|
|
match_by?: string;
|
|
exact_match?: boolean;
|
|
pattern?: string;
|
|
leading_str?: string;
|
|
trailing_str?: string;
|
|
prefix?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new OrRule(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.field = source["field"];
|
|
this.match_by = source["match_by"];
|
|
this.exact_match = source["exact_match"];
|
|
this.pattern = source["pattern"];
|
|
this.leading_str = source["leading_str"];
|
|
this.trailing_str = source["trailing_str"];
|
|
this.prefix = source["prefix"];
|
|
}
|
|
}
|
|
export class Def {
|
|
code: string;
|
|
name: string;
|
|
description?: string;
|
|
valid: boolean;
|
|
protected?: boolean;
|
|
url?: string;
|
|
download_url?: string;
|
|
ref_url?: string;
|
|
valid_from?: string;
|
|
valid_to?: string;
|
|
alias?: string;
|
|
ref_display?: string;
|
|
type?: string;
|
|
field: string;
|
|
match_by?: string;
|
|
exact_match?: boolean;
|
|
pattern: string;
|
|
leading_str?: string;
|
|
trailing_str?: string;
|
|
dynamic?: boolean;
|
|
or_rules?: OrRule[];
|
|
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;
|
|
version?: number;
|
|
user_edited?: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Def(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.name = source["name"];
|
|
this.description = source["description"];
|
|
this.valid = source["valid"];
|
|
this.protected = source["protected"];
|
|
this.url = source["url"];
|
|
this.download_url = source["download_url"];
|
|
this.ref_url = source["ref_url"];
|
|
this.valid_from = source["valid_from"];
|
|
this.valid_to = source["valid_to"];
|
|
this.alias = source["alias"];
|
|
this.ref_display = source["ref_display"];
|
|
this.type = source["type"];
|
|
this.field = source["field"];
|
|
this.match_by = source["match_by"];
|
|
this.exact_match = source["exact_match"];
|
|
this.pattern = source["pattern"];
|
|
this.leading_str = source["leading_str"];
|
|
this.trailing_str = source["trailing_str"];
|
|
this.dynamic = source["dynamic"];
|
|
this.or_rules = this.convertValues(source["or_rules"], OrRule);
|
|
this.dxcc_filter = source["dxcc_filter"];
|
|
this.valid_bands = source["valid_bands"];
|
|
this.valid_modes = source["valid_modes"];
|
|
this.emission = source["emission"];
|
|
this.confirm = source["confirm"];
|
|
this.validate = source["validate"];
|
|
this.grant_codes = source["grant_codes"];
|
|
this.export_credit_granted = source["export_credit_granted"];
|
|
this.total = source["total"];
|
|
this.builtin = source["builtin"];
|
|
this.version = source["version"];
|
|
this.user_edited = source["user_edited"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class Rejected {
|
|
candidate: string;
|
|
reason: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Rejected(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.candidate = source["candidate"];
|
|
this.reason = source["reason"];
|
|
}
|
|
}
|
|
export class Step {
|
|
rule: string;
|
|
field: string;
|
|
match_by?: string;
|
|
exact?: boolean;
|
|
pattern?: string;
|
|
field_value?: string;
|
|
candidates?: string[];
|
|
kept?: string[];
|
|
rejected?: Rejected[];
|
|
skipped?: boolean;
|
|
error?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Step(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.rule = source["rule"];
|
|
this.field = source["field"];
|
|
this.match_by = source["match_by"];
|
|
this.exact = source["exact"];
|
|
this.pattern = source["pattern"];
|
|
this.field_value = source["field_value"];
|
|
this.candidates = source["candidates"];
|
|
this.kept = source["kept"];
|
|
this.rejected = this.convertValues(source["rejected"], Rejected);
|
|
this.skipped = source["skipped"];
|
|
this.error = source["error"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class Explanation {
|
|
code: string;
|
|
in_scope: boolean;
|
|
scope_error?: string;
|
|
predefined: boolean;
|
|
ref_count: number;
|
|
steps: Step[];
|
|
manual?: string[];
|
|
result: string[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Explanation(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.in_scope = source["in_scope"];
|
|
this.scope_error = source["scope_error"];
|
|
this.predefined = source["predefined"];
|
|
this.ref_count = source["ref_count"];
|
|
this.steps = this.convertValues(source["steps"], Step);
|
|
this.manual = source["manual"];
|
|
this.result = source["result"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class Ref {
|
|
ref: string;
|
|
name?: string;
|
|
group?: string;
|
|
subgrp?: string;
|
|
worked: boolean;
|
|
confirmed: boolean;
|
|
validated: boolean;
|
|
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 FlexMeter {
|
|
id: number;
|
|
src?: string;
|
|
name?: string;
|
|
unit?: string;
|
|
slice: number;
|
|
value: number;
|
|
lo: number;
|
|
hi: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FlexMeter(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.src = source["src"];
|
|
this.name = source["name"];
|
|
this.unit = source["unit"];
|
|
this.slice = source["slice"];
|
|
this.value = source["value"];
|
|
this.lo = source["lo"];
|
|
this.hi = source["hi"];
|
|
}
|
|
}
|
|
export class FlexRadio {
|
|
ip: string;
|
|
port: number;
|
|
model: string;
|
|
nickname: string;
|
|
serial: string;
|
|
callsign: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FlexRadio(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.ip = source["ip"];
|
|
this.port = source["port"];
|
|
this.model = source["model"];
|
|
this.nickname = source["nickname"];
|
|
this.serial = source["serial"];
|
|
this.callsign = source["callsign"];
|
|
}
|
|
}
|
|
export class FlexSliceInfo {
|
|
index: number;
|
|
letter: string;
|
|
freq_hz: number;
|
|
mode?: string;
|
|
band?: string;
|
|
active: boolean;
|
|
tx: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FlexSliceInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.index = source["index"];
|
|
this.letter = source["letter"];
|
|
this.freq_hz = source["freq_hz"];
|
|
this.mode = source["mode"];
|
|
this.band = source["band"];
|
|
this.active = source["active"];
|
|
this.tx = source["tx"];
|
|
}
|
|
}
|
|
export class FlexTXState {
|
|
available: boolean;
|
|
model?: string;
|
|
slices?: FlexSliceInfo[];
|
|
rf_power: number;
|
|
tune_power: number;
|
|
tune: boolean;
|
|
transmitting: boolean;
|
|
vox_enable: boolean;
|
|
vox_level: number;
|
|
vox_delay: number;
|
|
proc_enable: boolean;
|
|
proc_level: number;
|
|
mon: boolean;
|
|
mon_level: number;
|
|
mic_level: number;
|
|
tx_filter_low: number;
|
|
tx_filter_high: number;
|
|
mic_profile?: string;
|
|
mic_profiles?: string[];
|
|
atu_status?: string;
|
|
atu_memories: boolean;
|
|
rx_avail: boolean;
|
|
split: boolean;
|
|
rx_freq_hz?: number;
|
|
tx_freq_hz?: number;
|
|
agc_mode?: string;
|
|
agc_threshold: number;
|
|
audio_level: number;
|
|
mute: boolean;
|
|
rx_ant?: string;
|
|
tx_ant?: string;
|
|
ant_list?: string[];
|
|
tx_ant_list?: string[];
|
|
nb: boolean;
|
|
nb_level: number;
|
|
nr: boolean;
|
|
nr_level: number;
|
|
anf: boolean;
|
|
anf_level: number;
|
|
wnb: boolean;
|
|
wnb_level: number;
|
|
rit: boolean;
|
|
rit_freq: number;
|
|
xit: boolean;
|
|
xit_freq: number;
|
|
mode?: string;
|
|
cw_speed: number;
|
|
cw_pitch: number;
|
|
cw_break_in_delay: number;
|
|
cw_sidetone: boolean;
|
|
cw_mon_level: number;
|
|
apf: boolean;
|
|
apf_level: number;
|
|
filter_lo: number;
|
|
filter_hi: number;
|
|
amp_available: boolean;
|
|
amp_model?: string;
|
|
amp_operate: boolean;
|
|
amp_fault?: string;
|
|
meters?: FlexMeter[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FlexTXState(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.available = source["available"];
|
|
this.model = source["model"];
|
|
this.slices = this.convertValues(source["slices"], FlexSliceInfo);
|
|
this.rf_power = source["rf_power"];
|
|
this.tune_power = source["tune_power"];
|
|
this.tune = source["tune"];
|
|
this.transmitting = source["transmitting"];
|
|
this.vox_enable = source["vox_enable"];
|
|
this.vox_level = source["vox_level"];
|
|
this.vox_delay = source["vox_delay"];
|
|
this.proc_enable = source["proc_enable"];
|
|
this.proc_level = source["proc_level"];
|
|
this.mon = source["mon"];
|
|
this.mon_level = source["mon_level"];
|
|
this.mic_level = source["mic_level"];
|
|
this.tx_filter_low = source["tx_filter_low"];
|
|
this.tx_filter_high = source["tx_filter_high"];
|
|
this.mic_profile = source["mic_profile"];
|
|
this.mic_profiles = source["mic_profiles"];
|
|
this.atu_status = source["atu_status"];
|
|
this.atu_memories = source["atu_memories"];
|
|
this.rx_avail = source["rx_avail"];
|
|
this.split = source["split"];
|
|
this.rx_freq_hz = source["rx_freq_hz"];
|
|
this.tx_freq_hz = source["tx_freq_hz"];
|
|
this.agc_mode = source["agc_mode"];
|
|
this.agc_threshold = source["agc_threshold"];
|
|
this.audio_level = source["audio_level"];
|
|
this.mute = source["mute"];
|
|
this.rx_ant = source["rx_ant"];
|
|
this.tx_ant = source["tx_ant"];
|
|
this.ant_list = source["ant_list"];
|
|
this.tx_ant_list = source["tx_ant_list"];
|
|
this.nb = source["nb"];
|
|
this.nb_level = source["nb_level"];
|
|
this.nr = source["nr"];
|
|
this.nr_level = source["nr_level"];
|
|
this.anf = source["anf"];
|
|
this.anf_level = source["anf_level"];
|
|
this.wnb = source["wnb"];
|
|
this.wnb_level = source["wnb_level"];
|
|
this.rit = source["rit"];
|
|
this.rit_freq = source["rit_freq"];
|
|
this.xit = source["xit"];
|
|
this.xit_freq = source["xit_freq"];
|
|
this.mode = source["mode"];
|
|
this.cw_speed = source["cw_speed"];
|
|
this.cw_pitch = source["cw_pitch"];
|
|
this.cw_break_in_delay = source["cw_break_in_delay"];
|
|
this.cw_sidetone = source["cw_sidetone"];
|
|
this.cw_mon_level = source["cw_mon_level"];
|
|
this.apf = source["apf"];
|
|
this.apf_level = source["apf_level"];
|
|
this.filter_lo = source["filter_lo"];
|
|
this.filter_hi = source["filter_hi"];
|
|
this.amp_available = source["amp_available"];
|
|
this.amp_model = source["amp_model"];
|
|
this.amp_operate = source["amp_operate"];
|
|
this.amp_fault = source["amp_fault"];
|
|
this.meters = this.convertValues(source["meters"], FlexMeter);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class IcomTXState {
|
|
available: boolean;
|
|
model?: string;
|
|
mode?: string;
|
|
transmitting: boolean;
|
|
split: boolean;
|
|
s_meter: number;
|
|
power_meter: number;
|
|
swr_meter: number;
|
|
rit_hz: number;
|
|
rit_on: boolean;
|
|
xit_on: boolean;
|
|
key_speed_wpm: number;
|
|
break_in: number;
|
|
rf_power: number;
|
|
mic_gain: number;
|
|
af_gain: number;
|
|
rf_gain: number;
|
|
nb: boolean;
|
|
nb_level: number;
|
|
nr: boolean;
|
|
nr_level: number;
|
|
anf: boolean;
|
|
apf: boolean;
|
|
agc?: string;
|
|
preamp: number;
|
|
att: number;
|
|
filter: number;
|
|
antenna: number;
|
|
pbt_inner: number;
|
|
pbt_outer: number;
|
|
manual_notch: boolean;
|
|
notch_pos: number;
|
|
squelch: number;
|
|
comp: boolean;
|
|
comp_level: number;
|
|
monitor: boolean;
|
|
mon_level: number;
|
|
vox: boolean;
|
|
vox_gain: number;
|
|
anti_vox: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new IcomTXState(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.available = source["available"];
|
|
this.model = source["model"];
|
|
this.mode = source["mode"];
|
|
this.transmitting = source["transmitting"];
|
|
this.split = source["split"];
|
|
this.s_meter = source["s_meter"];
|
|
this.power_meter = source["power_meter"];
|
|
this.swr_meter = source["swr_meter"];
|
|
this.rit_hz = source["rit_hz"];
|
|
this.rit_on = source["rit_on"];
|
|
this.xit_on = source["xit_on"];
|
|
this.key_speed_wpm = source["key_speed_wpm"];
|
|
this.break_in = source["break_in"];
|
|
this.rf_power = source["rf_power"];
|
|
this.mic_gain = source["mic_gain"];
|
|
this.af_gain = source["af_gain"];
|
|
this.rf_gain = source["rf_gain"];
|
|
this.nb = source["nb"];
|
|
this.nb_level = source["nb_level"];
|
|
this.nr = source["nr"];
|
|
this.nr_level = source["nr_level"];
|
|
this.anf = source["anf"];
|
|
this.apf = source["apf"];
|
|
this.agc = source["agc"];
|
|
this.preamp = source["preamp"];
|
|
this.att = source["att"];
|
|
this.filter = source["filter"];
|
|
this.antenna = source["antenna"];
|
|
this.pbt_inner = source["pbt_inner"];
|
|
this.pbt_outer = source["pbt_outer"];
|
|
this.manual_notch = source["manual_notch"];
|
|
this.notch_pos = source["notch_pos"];
|
|
this.squelch = source["squelch"];
|
|
this.comp = source["comp"];
|
|
this.comp_level = source["comp_level"];
|
|
this.monitor = source["monitor"];
|
|
this.mon_level = source["mon_level"];
|
|
this.vox = source["vox"];
|
|
this.vox_gain = source["vox_gain"];
|
|
this.anti_vox = source["anti_vox"];
|
|
}
|
|
}
|
|
export class RigState {
|
|
enabled: boolean;
|
|
connected: boolean;
|
|
backend?: string;
|
|
rig_num?: number;
|
|
rig?: string;
|
|
freq_hz?: number;
|
|
freq_rx_hz?: number;
|
|
split?: boolean;
|
|
mode?: string;
|
|
band?: string;
|
|
vfo?: string;
|
|
error?: string;
|
|
// Go type: time
|
|
updated_at?: any;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new RigState(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.connected = source["connected"];
|
|
this.backend = source["backend"];
|
|
this.rig_num = source["rig_num"];
|
|
this.rig = source["rig"];
|
|
this.freq_hz = source["freq_hz"];
|
|
this.freq_rx_hz = source["freq_rx_hz"];
|
|
this.split = source["split"];
|
|
this.mode = source["mode"];
|
|
this.band = source["band"];
|
|
this.vfo = source["vfo"];
|
|
this.error = source["error"];
|
|
this.updated_at = this.convertValues(source["updated_at"], null);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class ScopeSweep {
|
|
amp: number[];
|
|
seq: number;
|
|
low_hz: number;
|
|
high_hz: number;
|
|
fixed: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ScopeSweep(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.amp = source["amp"];
|
|
this.seq = source["seq"];
|
|
this.low_hz = source["low_hz"];
|
|
this.high_hz = source["high_hz"];
|
|
this.fixed = source["fixed"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace cluster {
|
|
|
|
export class ServerConfig {
|
|
id: number;
|
|
name: string;
|
|
host: string;
|
|
port: number;
|
|
login_override: string;
|
|
password?: string;
|
|
init_commands: string;
|
|
enabled: boolean;
|
|
sort_order: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ServerConfig(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.login_override = source["login_override"];
|
|
this.password = source["password"];
|
|
this.init_commands = source["init_commands"];
|
|
this.enabled = source["enabled"];
|
|
this.sort_order = source["sort_order"];
|
|
}
|
|
}
|
|
export class ServerStatus {
|
|
server_id: number;
|
|
name: string;
|
|
host: string;
|
|
port: number;
|
|
state: string;
|
|
login?: string;
|
|
error?: string;
|
|
// Go type: time
|
|
connected_at?: any;
|
|
spots_count?: number;
|
|
retries?: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ServerStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.server_id = source["server_id"];
|
|
this.name = source["name"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.state = source["state"];
|
|
this.login = source["login"];
|
|
this.error = source["error"];
|
|
this.connected_at = this.convertValues(source["connected_at"], null);
|
|
this.spots_count = source["spots_count"];
|
|
this.retries = source["retries"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace contest {
|
|
|
|
export class Def {
|
|
code: string;
|
|
name: string;
|
|
exchange: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Def(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.name = source["name"];
|
|
this.exchange = source["exchange"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace extsvc {
|
|
|
|
export class ServiceConfig {
|
|
api_key: string;
|
|
email: string;
|
|
username: string;
|
|
password: string;
|
|
callsign: string;
|
|
code: string;
|
|
qth_nickname: string;
|
|
force_station_callsign: string;
|
|
tqsl_path: string;
|
|
station_location: string;
|
|
key_password: string;
|
|
upload_flags: string[];
|
|
write_log: boolean;
|
|
auto_upload: boolean;
|
|
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.code = source["code"];
|
|
this.qth_nickname = source["qth_nickname"];
|
|
this.force_station_callsign = source["force_station_callsign"];
|
|
this.tqsl_path = source["tqsl_path"];
|
|
this.station_location = source["station_location"];
|
|
this.key_password = source["key_password"];
|
|
this.upload_flags = source["upload_flags"];
|
|
this.write_log = source["write_log"];
|
|
this.auto_upload = source["auto_upload"];
|
|
this.upload_mode = source["upload_mode"];
|
|
}
|
|
}
|
|
export class ExternalServices {
|
|
qrz: ServiceConfig;
|
|
clublog: ServiceConfig;
|
|
lotw: ServiceConfig;
|
|
hrdlog: ServiceConfig;
|
|
eqsl: 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);
|
|
this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
|
|
this.eqsl = this.convertValues(source["eqsl"], 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 lotwusers {
|
|
|
|
export class Info {
|
|
is_user: boolean;
|
|
last_upload?: string;
|
|
days_ago: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Info(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.is_user = source["is_user"];
|
|
this.last_upload = source["last_upload"];
|
|
this.days_ago = source["days_ago"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace main {
|
|
|
|
export class ADIFWatchFile {
|
|
path: string;
|
|
enabled: boolean;
|
|
offset: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ADIFWatchFile(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.path = source["path"];
|
|
this.enabled = source["enabled"];
|
|
this.offset = source["offset"];
|
|
}
|
|
}
|
|
export class ADIFMonitorConfig {
|
|
enabled: boolean;
|
|
files: ADIFWatchFile[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ADIFMonitorConfig(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.files = this.convertValues(source["files"], ADIFWatchFile);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class AntGeniusSettings {
|
|
enabled: boolean;
|
|
host: string;
|
|
password: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AntGeniusSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.host = source["host"];
|
|
this.password = source["password"];
|
|
}
|
|
}
|
|
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 AutostartLaunchResult {
|
|
id: string;
|
|
name: string;
|
|
status: string;
|
|
message: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AutostartLaunchResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.status = source["status"];
|
|
this.message = source["message"];
|
|
}
|
|
}
|
|
export class AutostartProgram {
|
|
id: string;
|
|
name: string;
|
|
path: string;
|
|
args: string;
|
|
enabled: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AutostartProgram(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.path = source["path"];
|
|
this.args = source["args"];
|
|
this.enabled = source["enabled"];
|
|
}
|
|
}
|
|
export class AwardExplain {
|
|
qso: qso.QSO;
|
|
explanation: award.Explanation;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardExplain(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.qso = this.convertValues(source["qso"], qso.QSO);
|
|
this.explanation = this.convertValues(source["explanation"], award.Explanation);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class AwardImportPreviewEntry {
|
|
code: string;
|
|
name: string;
|
|
references: number;
|
|
exists: boolean;
|
|
mine_name: string;
|
|
mine_refs: number;
|
|
protected: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardImportPreviewEntry(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.name = source["name"];
|
|
this.references = source["references"];
|
|
this.exists = source["exists"];
|
|
this.mine_name = source["mine_name"];
|
|
this.mine_refs = source["mine_refs"];
|
|
this.protected = source["protected"];
|
|
}
|
|
}
|
|
export class AwardImportPreview {
|
|
path: string;
|
|
awards: AwardImportPreviewEntry[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardImportPreview(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.path = source["path"];
|
|
this.awards = this.convertValues(source["awards"], AwardImportPreviewEntry);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class AwardImportResult {
|
|
awards: number;
|
|
references: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardImportResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.awards = source["awards"];
|
|
this.references = source["references"];
|
|
}
|
|
}
|
|
export class AwardRefMeta {
|
|
code: string;
|
|
count: number;
|
|
updated_at: string;
|
|
can_update: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardRefMeta(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.count = source["count"];
|
|
this.updated_at = source["updated_at"];
|
|
this.can_update = source["can_update"];
|
|
}
|
|
}
|
|
export class AwardStatRow {
|
|
label: string;
|
|
cells: number[];
|
|
total: number;
|
|
grand_total: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardStatRow(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.label = source["label"];
|
|
this.cells = source["cells"];
|
|
this.total = source["total"];
|
|
this.grand_total = source["grand_total"];
|
|
}
|
|
}
|
|
export class AwardStatsResult {
|
|
code: string;
|
|
bands: string[];
|
|
rows: AwardStatRow[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardStatsResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.bands = source["bands"];
|
|
this.rows = this.convertValues(source["rows"], AwardStatRow);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class AwardUpdate {
|
|
code: string;
|
|
name: string;
|
|
from: number;
|
|
to: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AwardUpdate(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.code = source["code"];
|
|
this.name = source["name"];
|
|
this.from = source["from"];
|
|
this.to = source["to"];
|
|
}
|
|
}
|
|
export class BackfillUSCountiesResult {
|
|
scanned: number;
|
|
county: number;
|
|
grid: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new BackfillUSCountiesResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.scanned = source["scanned"];
|
|
this.county = source["county"];
|
|
this.grid = source["grid"];
|
|
}
|
|
}
|
|
export class BackupSettings {
|
|
enabled: boolean;
|
|
folder: string;
|
|
rotation: number;
|
|
zip: boolean;
|
|
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;
|
|
flex_host: string;
|
|
flex_port: number;
|
|
flex_spots: boolean;
|
|
flex_decode_spots: boolean;
|
|
flex_decode_secs: number;
|
|
icom_port: string;
|
|
icom_baud: number;
|
|
icom_addr: number;
|
|
icom_net_host: string;
|
|
icom_net_user: string;
|
|
icom_net_pass: string;
|
|
icom_net_audio: boolean;
|
|
tci_host: string;
|
|
tci_port: number;
|
|
tci_spots: boolean;
|
|
poll_ms: number;
|
|
delay_ms: number;
|
|
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.flex_host = source["flex_host"];
|
|
this.flex_port = source["flex_port"];
|
|
this.flex_spots = source["flex_spots"];
|
|
this.flex_decode_spots = source["flex_decode_spots"];
|
|
this.flex_decode_secs = source["flex_decode_secs"];
|
|
this.icom_port = source["icom_port"];
|
|
this.icom_baud = source["icom_baud"];
|
|
this.icom_addr = source["icom_addr"];
|
|
this.icom_net_host = source["icom_net_host"];
|
|
this.icom_net_user = source["icom_net_user"];
|
|
this.icom_net_pass = source["icom_net_pass"];
|
|
this.icom_net_audio = source["icom_net_audio"];
|
|
this.tci_host = source["tci_host"];
|
|
this.tci_port = source["tci_port"];
|
|
this.tci_spots = source["tci_spots"];
|
|
this.poll_ms = source["poll_ms"];
|
|
this.delay_ms = source["delay_ms"];
|
|
this.digital_default = source["digital_default"];
|
|
}
|
|
}
|
|
export class CabrilloResult {
|
|
count: number;
|
|
path: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new CabrilloResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.count = source["count"];
|
|
this.path = source["path"];
|
|
}
|
|
}
|
|
export class ChangelogEntry {
|
|
version: string;
|
|
date: string;
|
|
en: string[];
|
|
fr: string[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ChangelogEntry(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.version = source["version"];
|
|
this.date = source["date"];
|
|
this.en = source["en"];
|
|
this.fr = source["fr"];
|
|
}
|
|
}
|
|
export class ChatMessage {
|
|
id: number;
|
|
operator: string;
|
|
station: string;
|
|
message: string;
|
|
created_at: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ChatMessage(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.operator = source["operator"];
|
|
this.station = source["station"];
|
|
this.message = source["message"];
|
|
this.created_at = source["created_at"];
|
|
}
|
|
}
|
|
export class ChatPresence {
|
|
operator: string;
|
|
station: string;
|
|
ago_secs: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ChatPresence(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.operator = source["operator"];
|
|
this.station = source["station"];
|
|
this.ago_secs = source["ago_secs"];
|
|
}
|
|
}
|
|
export class ClublogCtyInfo {
|
|
enabled: boolean;
|
|
loaded: boolean;
|
|
date: string;
|
|
count: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ClublogCtyInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.loaded = source["loaded"];
|
|
this.date = source["date"];
|
|
this.count = source["count"];
|
|
}
|
|
}
|
|
export class ContestBandRow {
|
|
band: string;
|
|
count: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ContestBandRow(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.band = source["band"];
|
|
this.count = source["count"];
|
|
}
|
|
}
|
|
export class ContestStatsResult {
|
|
qsos: number;
|
|
by_band: ContestBandRow[];
|
|
mult: number;
|
|
mult_label: string;
|
|
score: number;
|
|
last_hour: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ContestStatsResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.qsos = source["qsos"];
|
|
this.by_band = this.convertValues(source["by_band"], ContestBandRow);
|
|
this.mult = source["mult"];
|
|
this.mult_label = source["mult_label"];
|
|
this.score = source["score"];
|
|
this.last_hour = source["last_hour"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class CtyDatInfo {
|
|
path: string;
|
|
entities: number;
|
|
loaded_at?: string;
|
|
file_mod_time?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new CtyDatInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.path = source["path"];
|
|
this.entities = source["entities"];
|
|
this.loaded_at = source["loaded_at"];
|
|
this.file_mod_time = source["file_mod_time"];
|
|
}
|
|
}
|
|
export class DBBackendStatus {
|
|
active: string;
|
|
fallback: boolean;
|
|
error: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new DBBackendStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.active = source["active"];
|
|
this.fallback = source["fallback"];
|
|
this.error = source["error"];
|
|
}
|
|
}
|
|
export class DBConnectionInfo {
|
|
backend: string;
|
|
label: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new DBConnectionInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.backend = source["backend"];
|
|
this.label = source["label"];
|
|
}
|
|
}
|
|
export class DVKMessage {
|
|
slot: number;
|
|
label: string;
|
|
has_audio: boolean;
|
|
duration_sec: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new DVKMessage(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.slot = source["slot"];
|
|
this.label = source["label"];
|
|
this.has_audio = source["has_audio"];
|
|
this.duration_sec = source["duration_sec"];
|
|
}
|
|
}
|
|
export class DVKStatus {
|
|
recording: boolean;
|
|
playing: boolean;
|
|
rec_slot: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new DVKStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.recording = source["recording"];
|
|
this.playing = source["playing"];
|
|
this.rec_slot = source["rec_slot"];
|
|
}
|
|
}
|
|
export class 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 DuplicateGroup {
|
|
key: string;
|
|
qsos: qso.QSO[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new DuplicateGroup(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.key = source["key"];
|
|
this.qsos = this.convertValues(source["qsos"], qso.QSO);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class EmailSettings {
|
|
enabled: boolean;
|
|
smtp_host: string;
|
|
smtp_port: number;
|
|
smtp_user: string;
|
|
smtp_password: string;
|
|
from: string;
|
|
reply_to: string;
|
|
encryption: string;
|
|
auth: boolean;
|
|
auto_send: boolean;
|
|
subject: string;
|
|
body: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new EmailSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.smtp_host = source["smtp_host"];
|
|
this.smtp_port = source["smtp_port"];
|
|
this.smtp_user = source["smtp_user"];
|
|
this.smtp_password = source["smtp_password"];
|
|
this.from = source["from"];
|
|
this.reply_to = source["reply_to"];
|
|
this.encryption = source["encryption"];
|
|
this.auth = source["auth"];
|
|
this.auto_send = source["auto_send"];
|
|
this.subject = source["subject"];
|
|
this.body = source["body"];
|
|
}
|
|
}
|
|
export class 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 LiveStation {
|
|
operator: string;
|
|
station: string;
|
|
freq_hz: number;
|
|
band: string;
|
|
mode: string;
|
|
online: boolean;
|
|
version: string;
|
|
age_sec: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new LiveStation(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.operator = source["operator"];
|
|
this.station = source["station"];
|
|
this.freq_hz = source["freq_hz"];
|
|
this.band = source["band"];
|
|
this.mode = source["mode"];
|
|
this.online = source["online"];
|
|
this.version = source["version"];
|
|
this.age_sec = source["age_sec"];
|
|
}
|
|
}
|
|
export class LoTWUsersStatus {
|
|
count: number;
|
|
updated?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new LoTWUsersStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.count = source["count"];
|
|
this.updated = source["updated"];
|
|
}
|
|
}
|
|
export class LookupSettings {
|
|
qrz_user: string;
|
|
qrz_password: string;
|
|
hamqth_user: string;
|
|
hamqth_password: string;
|
|
primary: string;
|
|
failsafe: string;
|
|
download_images: boolean;
|
|
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 MySQLSettings {
|
|
enabled: boolean;
|
|
host: string;
|
|
port: number;
|
|
user: string;
|
|
password: string;
|
|
database: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new MySQLSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.user = source["user"];
|
|
this.password = source["password"];
|
|
this.database = source["database"];
|
|
}
|
|
}
|
|
export class OfflineStatus {
|
|
offline: boolean;
|
|
pending: number;
|
|
path: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new OfflineStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.offline = source["offline"];
|
|
this.pending = source["pending"];
|
|
this.path = source["path"];
|
|
}
|
|
}
|
|
export class PGXLSettings {
|
|
enabled: boolean;
|
|
type: string;
|
|
transport: string;
|
|
host: string;
|
|
port: number;
|
|
com_port: string;
|
|
baud: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new PGXLSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.type = source["type"];
|
|
this.transport = source["transport"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.com_port = source["com_port"];
|
|
this.baud = source["baud"];
|
|
}
|
|
}
|
|
export class POTAUnmatched {
|
|
activator: string;
|
|
date: string;
|
|
band: string;
|
|
reference: string;
|
|
reason: string;
|
|
qso_id: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new POTAUnmatched(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.activator = source["activator"];
|
|
this.date = source["date"];
|
|
this.band = source["band"];
|
|
this.reference = source["reference"];
|
|
this.reason = source["reason"];
|
|
this.qso_id = source["qso_id"];
|
|
}
|
|
}
|
|
export class POTASyncResult {
|
|
fetched: number;
|
|
updated: number;
|
|
already_tagged: number;
|
|
added: number;
|
|
unmatched: number;
|
|
unmatched_list: POTAUnmatched[];
|
|
skipped_other_call: number;
|
|
my_call: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new POTASyncResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.fetched = source["fetched"];
|
|
this.updated = source["updated"];
|
|
this.already_tagged = source["already_tagged"];
|
|
this.added = source["added"];
|
|
this.unmatched = source["unmatched"];
|
|
this.unmatched_list = this.convertValues(source["unmatched_list"], POTAUnmatched);
|
|
this.skipped_other_call = source["skipped_other_call"];
|
|
this.my_call = source["my_call"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class QSLBulkUpdate {
|
|
sent_status: string;
|
|
rcvd_status: string;
|
|
sent_date: string;
|
|
rcvd_date: string;
|
|
via: string;
|
|
notes: string;
|
|
comment: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSLBulkUpdate(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.sent_status = source["sent_status"];
|
|
this.rcvd_status = source["rcvd_status"];
|
|
this.sent_date = source["sent_date"];
|
|
this.rcvd_date = source["rcvd_date"];
|
|
this.via = source["via"];
|
|
this.notes = source["notes"];
|
|
this.comment = source["comment"];
|
|
}
|
|
}
|
|
export class QSLDefaults {
|
|
qsl_sent: string;
|
|
qsl_rcvd: string;
|
|
lotw_sent: string;
|
|
lotw_rcvd: string;
|
|
eqsl_sent: string;
|
|
eqsl_rcvd: string;
|
|
clublog_status: string;
|
|
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 QSLEmailTemplates {
|
|
subject: string;
|
|
body: string;
|
|
auto_send: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSLEmailTemplates(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.subject = source["subject"];
|
|
this.body = source["body"];
|
|
this.auto_send = source["auto_send"];
|
|
}
|
|
}
|
|
export class QSLFontInfo {
|
|
family: string;
|
|
kind: string;
|
|
variable: boolean;
|
|
data_b64: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSLFontInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.family = source["family"];
|
|
this.kind = source["kind"];
|
|
this.variable = source["variable"];
|
|
this.data_b64 = source["data_b64"];
|
|
}
|
|
}
|
|
export class QSLPresetInfo {
|
|
name: string;
|
|
label: string;
|
|
params: string[];
|
|
defaults: qslcard.StyleParams;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSLPresetInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.name = source["name"];
|
|
this.label = source["label"];
|
|
this.params = source["params"];
|
|
this.defaults = this.convertValues(source["defaults"], qslcard.StyleParams);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class QSLTemplateInfo {
|
|
id: number;
|
|
name: string;
|
|
profile_id?: number;
|
|
is_default: boolean;
|
|
updated_at: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSLTemplateInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.profile_id = source["profile_id"];
|
|
this.is_default = source["is_default"];
|
|
this.updated_at = source["updated_at"];
|
|
}
|
|
}
|
|
export class 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 QSORate {
|
|
last10: number;
|
|
last60: number;
|
|
team_last10: number;
|
|
team_last60: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QSORate(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.last10 = source["last10"];
|
|
this.last60 = source["last60"];
|
|
this.team_last10 = source["team_last10"];
|
|
this.team_last60 = source["team_last60"];
|
|
}
|
|
}
|
|
export class RelayAutoRule {
|
|
device_id: string;
|
|
relay: number;
|
|
mode: string;
|
|
freq_lo_khz: number;
|
|
freq_hi_khz: number;
|
|
bands: string[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new RelayAutoRule(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.device_id = source["device_id"];
|
|
this.relay = source["relay"];
|
|
this.mode = source["mode"];
|
|
this.freq_lo_khz = source["freq_lo_khz"];
|
|
this.freq_hi_khz = source["freq_hi_khz"];
|
|
this.bands = source["bands"];
|
|
}
|
|
}
|
|
export class RelayAutoConfig {
|
|
enabled: boolean;
|
|
rules: RelayAutoRule[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new RelayAutoConfig(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.rules = this.convertValues(source["rules"], RelayAutoRule);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class 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;
|
|
type: string;
|
|
host: string;
|
|
port: number;
|
|
has_elevation: boolean;
|
|
rotator_num: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new RotatorSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.type = source["type"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.has_elevation = source["has_elevation"];
|
|
this.rotator_num = source["rotator_num"];
|
|
}
|
|
}
|
|
export class SecretStatus {
|
|
has_passphrase: boolean;
|
|
unlocked: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new SecretStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.has_passphrase = source["has_passphrase"];
|
|
this.unlocked = source["unlocked"];
|
|
}
|
|
}
|
|
export class SpotQuery {
|
|
call: string;
|
|
band: string;
|
|
mode: string;
|
|
pota_ref?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new SpotQuery(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.call = source["call"];
|
|
this.band = source["band"];
|
|
this.mode = source["mode"];
|
|
this.pota_ref = source["pota_ref"];
|
|
}
|
|
}
|
|
export class SpotStatus {
|
|
call: string;
|
|
band: string;
|
|
mode: string;
|
|
country?: string;
|
|
continent?: string;
|
|
status: string;
|
|
worked_call: boolean;
|
|
new_county: boolean;
|
|
new_pota: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new SpotStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.call = source["call"];
|
|
this.band = source["band"];
|
|
this.mode = source["mode"];
|
|
this.country = source["country"];
|
|
this.continent = source["continent"];
|
|
this.status = source["status"];
|
|
this.worked_call = source["worked_call"];
|
|
this.new_county = source["new_county"];
|
|
this.new_pota = source["new_pota"];
|
|
}
|
|
}
|
|
export class StartupStatus {
|
|
ok: boolean;
|
|
err: string;
|
|
db_path: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StartupStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.ok = source["ok"];
|
|
this.err = source["err"];
|
|
this.db_path = source["db_path"];
|
|
}
|
|
}
|
|
export class StationDevice {
|
|
id: string;
|
|
type: string;
|
|
name: string;
|
|
host: string;
|
|
user?: string;
|
|
pass?: string;
|
|
channels?: number;
|
|
labels: string[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StationDevice(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.type = source["type"];
|
|
this.name = source["name"];
|
|
this.host = source["host"];
|
|
this.user = source["user"];
|
|
this.pass = source["pass"];
|
|
this.channels = source["channels"];
|
|
this.labels = source["labels"];
|
|
}
|
|
}
|
|
export class StationRelay {
|
|
number: number;
|
|
label: string;
|
|
on: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StationRelay(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.number = source["number"];
|
|
this.label = source["label"];
|
|
this.on = source["on"];
|
|
}
|
|
}
|
|
export class StationDeviceStatus {
|
|
id: string;
|
|
name: string;
|
|
type: string;
|
|
connected: boolean;
|
|
error?: string;
|
|
relays: StationRelay[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StationDeviceStatus(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.type = source["type"];
|
|
this.connected = source["connected"];
|
|
this.error = source["error"];
|
|
this.relays = this.convertValues(source["relays"], StationRelay);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class StationInfoComputed {
|
|
country: string;
|
|
dxcc: number;
|
|
cqz: number;
|
|
ituz: number;
|
|
lat: number;
|
|
lon: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StationInfoComputed(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.country = source["country"];
|
|
this.dxcc = source["dxcc"];
|
|
this.cqz = source["cqz"];
|
|
this.ituz = source["ituz"];
|
|
this.lat = source["lat"];
|
|
this.lon = source["lon"];
|
|
}
|
|
}
|
|
|
|
export class StationSettings {
|
|
callsign: string;
|
|
operator: string;
|
|
my_grid: string;
|
|
my_country: string;
|
|
my_sota_ref: string;
|
|
my_pota_ref: string;
|
|
|
|
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 ULSStatusResult {
|
|
count: number;
|
|
updated_at: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ULSStatusResult(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.count = source["count"];
|
|
this.updated_at = source["updated_at"];
|
|
}
|
|
}
|
|
export class UltrabeamSettings {
|
|
enabled: boolean;
|
|
type: string;
|
|
transport: string;
|
|
host: string;
|
|
port: number;
|
|
com: string;
|
|
baud: number;
|
|
follow: boolean;
|
|
step_khz: number;
|
|
tx_inhibit: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new UltrabeamSettings(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.type = source["type"];
|
|
this.transport = source["transport"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.com = source["com"];
|
|
this.baud = source["baud"];
|
|
this.follow = source["follow"];
|
|
this.step_khz = source["step_khz"];
|
|
this.tx_inhibit = source["tx_inhibit"];
|
|
}
|
|
}
|
|
export class UltrabeamStatusInfo {
|
|
enabled: boolean;
|
|
type: string;
|
|
connected: boolean;
|
|
direction: number;
|
|
frequency: number;
|
|
band: number;
|
|
moving: boolean;
|
|
elements: number[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new UltrabeamStatusInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.enabled = source["enabled"];
|
|
this.type = source["type"];
|
|
this.connected = source["connected"];
|
|
this.direction = source["direction"];
|
|
this.frequency = source["frequency"];
|
|
this.band = source["band"];
|
|
this.moving = source["moving"];
|
|
this.elements = source["elements"];
|
|
}
|
|
}
|
|
export class UpdateInfo {
|
|
current: string;
|
|
latest: string;
|
|
available: boolean;
|
|
url: string;
|
|
download_url: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new UpdateInfo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.current = source["current"];
|
|
this.latest = source["latest"];
|
|
this.available = source["available"];
|
|
this.url = source["url"];
|
|
this.download_url = source["download_url"];
|
|
}
|
|
}
|
|
export class WKMacro {
|
|
label: string;
|
|
text: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new WKMacro(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.label = source["label"];
|
|
this.text = source["text"];
|
|
}
|
|
}
|
|
export class 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 netctl {
|
|
|
|
export class Station {
|
|
callsign: string;
|
|
name?: string;
|
|
qth?: string;
|
|
country?: string;
|
|
dxcc?: number;
|
|
itu?: number;
|
|
cq?: number;
|
|
grid?: string;
|
|
address?: string;
|
|
state?: string;
|
|
cnty?: string;
|
|
cont?: string;
|
|
lat?: number;
|
|
lon?: number;
|
|
email?: string;
|
|
groups?: string;
|
|
sig?: string;
|
|
sig_info?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Station(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.callsign = source["callsign"];
|
|
this.name = source["name"];
|
|
this.qth = source["qth"];
|
|
this.country = source["country"];
|
|
this.dxcc = source["dxcc"];
|
|
this.itu = source["itu"];
|
|
this.cq = source["cq"];
|
|
this.grid = source["grid"];
|
|
this.address = source["address"];
|
|
this.state = source["state"];
|
|
this.cnty = source["cnty"];
|
|
this.cont = source["cont"];
|
|
this.lat = source["lat"];
|
|
this.lon = source["lon"];
|
|
this.email = source["email"];
|
|
this.groups = source["groups"];
|
|
this.sig = source["sig"];
|
|
this.sig_info = source["sig_info"];
|
|
}
|
|
}
|
|
export class Net {
|
|
id: string;
|
|
name: string;
|
|
default_rst_sent?: string;
|
|
default_rst_rcvd?: string;
|
|
default_comment?: string;
|
|
stations?: Station[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Net(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.default_rst_sent = source["default_rst_sent"];
|
|
this.default_rst_rcvd = source["default_rst_rcvd"];
|
|
this.default_comment = source["default_comment"];
|
|
this.stations = this.convertValues(source["stations"], Station);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace operating {
|
|
|
|
export class AntennaBand {
|
|
band: string;
|
|
is_default: boolean;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new AntennaBand(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.band = source["band"];
|
|
this.is_default = source["is_default"];
|
|
}
|
|
}
|
|
export class Antenna {
|
|
id: number;
|
|
station_id: number;
|
|
name: string;
|
|
sort_order: number;
|
|
bands: AntennaBand[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Antenna(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.station_id = source["station_id"];
|
|
this.name = source["name"];
|
|
this.sort_order = source["sort_order"];
|
|
this.bands = this.convertValues(source["bands"], AntennaBand);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
export class BandDefault {
|
|
station_id: number;
|
|
station_name: string;
|
|
antenna_id: number;
|
|
antenna_name: string;
|
|
tx_pwr?: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new BandDefault(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.station_id = source["station_id"];
|
|
this.station_name = source["station_name"];
|
|
this.antenna_id = source["antenna_id"];
|
|
this.antenna_name = source["antenna_name"];
|
|
this.tx_pwr = source["tx_pwr"];
|
|
}
|
|
}
|
|
export class Station {
|
|
id: number;
|
|
profile_id: number;
|
|
name: string;
|
|
tx_pwr?: number;
|
|
sort_order: number;
|
|
antennas?: Antenna[];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Station(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.profile_id = source["profile_id"];
|
|
this.name = source["name"];
|
|
this.tx_pwr = source["tx_pwr"];
|
|
this.sort_order = source["sort_order"];
|
|
this.antennas = this.convertValues(source["antennas"], Antenna);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace powergenius {
|
|
|
|
export class Status {
|
|
connected: boolean;
|
|
host?: string;
|
|
last_error?: string;
|
|
state?: string;
|
|
fan_mode?: string;
|
|
temperature: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Status(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.connected = source["connected"];
|
|
this.host = source["host"];
|
|
this.last_error = source["last_error"];
|
|
this.state = source["state"];
|
|
this.fan_mode = source["fan_mode"];
|
|
this.temperature = source["temperature"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace profile {
|
|
|
|
export class ProfileDB {
|
|
backend: string;
|
|
host: string;
|
|
port: number;
|
|
user: string;
|
|
password: string;
|
|
database: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ProfileDB(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.backend = source["backend"];
|
|
this.host = source["host"];
|
|
this.port = source["port"];
|
|
this.user = source["user"];
|
|
this.password = source["password"];
|
|
this.database = source["database"];
|
|
}
|
|
}
|
|
export class Profile {
|
|
id: number;
|
|
name: string;
|
|
callsign: string;
|
|
operator: string;
|
|
op_name: string;
|
|
owner_callsign: string;
|
|
my_grid: string;
|
|
my_country: string;
|
|
my_state: string;
|
|
my_cnty: string;
|
|
my_street: string;
|
|
my_city: string;
|
|
my_postal_code: string;
|
|
my_sota_ref: string;
|
|
my_pota_ref: string;
|
|
my_rig: string;
|
|
my_antenna: string;
|
|
my_dxcc?: number;
|
|
my_cqz?: number;
|
|
my_ituz?: number;
|
|
my_lat?: number;
|
|
my_lon?: number;
|
|
tx_pwr?: number;
|
|
is_active: boolean;
|
|
sort_order: number;
|
|
db: ProfileDB;
|
|
// Go type: time
|
|
created_at: any;
|
|
// Go type: time
|
|
updated_at: any;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Profile(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.name = source["name"];
|
|
this.callsign = source["callsign"];
|
|
this.operator = source["operator"];
|
|
this.op_name = source["op_name"];
|
|
this.owner_callsign = source["owner_callsign"];
|
|
this.my_grid = source["my_grid"];
|
|
this.my_country = source["my_country"];
|
|
this.my_state = source["my_state"];
|
|
this.my_cnty = source["my_cnty"];
|
|
this.my_street = source["my_street"];
|
|
this.my_city = source["my_city"];
|
|
this.my_postal_code = source["my_postal_code"];
|
|
this.my_sota_ref = source["my_sota_ref"];
|
|
this.my_pota_ref = source["my_pota_ref"];
|
|
this.my_rig = source["my_rig"];
|
|
this.my_antenna = source["my_antenna"];
|
|
this.my_dxcc = source["my_dxcc"];
|
|
this.my_cqz = source["my_cqz"];
|
|
this.my_ituz = source["my_ituz"];
|
|
this.my_lat = source["my_lat"];
|
|
this.my_lon = source["my_lon"];
|
|
this.tx_pwr = source["tx_pwr"];
|
|
this.is_active = source["is_active"];
|
|
this.sort_order = source["sort_order"];
|
|
this.db = this.convertValues(source["db"], ProfileDB);
|
|
this.created_at = this.convertValues(source["created_at"], null);
|
|
this.updated_at = this.convertValues(source["updated_at"], null);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace qslcard {
|
|
|
|
export class Bevel {
|
|
dx: number;
|
|
dy: number;
|
|
dark: string;
|
|
light: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Bevel(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.dx = source["dx"];
|
|
this.dy = source["dy"];
|
|
this.dark = source["dark"];
|
|
this.light = source["light"];
|
|
}
|
|
}
|
|
export class FxParams {
|
|
plump?: number;
|
|
edge?: number;
|
|
outerw?: number;
|
|
gloss?: number;
|
|
gloss_h?: number;
|
|
gloss_i?: number;
|
|
inner_b?: number;
|
|
depth?: number;
|
|
angle?: number;
|
|
slant?: number;
|
|
grunge?: number;
|
|
bevel?: number;
|
|
seed?: number;
|
|
dark?: string;
|
|
outer?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new FxParams(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.plump = source["plump"];
|
|
this.edge = source["edge"];
|
|
this.outerw = source["outerw"];
|
|
this.gloss = source["gloss"];
|
|
this.gloss_h = source["gloss_h"];
|
|
this.gloss_i = source["gloss_i"];
|
|
this.inner_b = source["inner_b"];
|
|
this.depth = source["depth"];
|
|
this.angle = source["angle"];
|
|
this.slant = source["slant"];
|
|
this.grunge = source["grunge"];
|
|
this.bevel = source["bevel"];
|
|
this.seed = source["seed"];
|
|
this.dark = source["dark"];
|
|
this.outer = source["outer"];
|
|
}
|
|
}
|
|
export class Halo {
|
|
color: string;
|
|
blur: number;
|
|
opacity: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Halo(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.color = source["color"];
|
|
this.blur = source["blur"];
|
|
this.opacity = source["opacity"];
|
|
}
|
|
}
|
|
export class ShadowFx {
|
|
dx: number;
|
|
dy: number;
|
|
blur: number;
|
|
color: string;
|
|
opacity: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ShadowFx(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.dx = source["dx"];
|
|
this.dy = source["dy"];
|
|
this.blur = source["blur"];
|
|
this.color = source["color"];
|
|
this.opacity = source["opacity"];
|
|
}
|
|
}
|
|
export class Shine {
|
|
coverage: number;
|
|
opacity: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Shine(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.coverage = source["coverage"];
|
|
this.opacity = source["opacity"];
|
|
}
|
|
}
|
|
export class StyleParams {
|
|
gradient?: string[];
|
|
shine?: Shine;
|
|
outline_color?: string;
|
|
outline_width?: number;
|
|
halo?: Halo;
|
|
shadow?: ShadowFx;
|
|
bevel_offset?: Bevel;
|
|
color?: string;
|
|
fx?: FxParams;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new StyleParams(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.gradient = source["gradient"];
|
|
this.shine = this.convertValues(source["shine"], Shine);
|
|
this.outline_color = source["outline_color"];
|
|
this.outline_width = source["outline_width"];
|
|
this.halo = this.convertValues(source["halo"], Halo);
|
|
this.shadow = this.convertValues(source["shadow"], ShadowFx);
|
|
this.bevel_offset = this.convertValues(source["bevel_offset"], Bevel);
|
|
this.color = source["color"];
|
|
this.fx = this.convertValues(source["fx"], FxParams);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace qso {
|
|
|
|
export class BandCategory {
|
|
band: string;
|
|
cw: number;
|
|
phone: number;
|
|
data: number;
|
|
total: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new BandCategory(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.band = source["band"];
|
|
this.cw = source["cw"];
|
|
this.phone = source["phone"];
|
|
this.data = source["data"];
|
|
this.total = source["total"];
|
|
}
|
|
}
|
|
export class BandMode {
|
|
band: string;
|
|
mode: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new BandMode(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.band = source["band"];
|
|
this.mode = source["mode"];
|
|
}
|
|
}
|
|
export class BandStatus {
|
|
band: string;
|
|
class: string;
|
|
status: string;
|
|
|
|
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 Bucket {
|
|
key: string;
|
|
count: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Bucket(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.key = source["key"];
|
|
this.count = source["count"];
|
|
}
|
|
}
|
|
export class Condition {
|
|
field: string;
|
|
op: string;
|
|
value: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Condition(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.field = source["field"];
|
|
this.op = source["op"];
|
|
this.value = source["value"];
|
|
}
|
|
}
|
|
export class ContestRun {
|
|
id: string;
|
|
year: number;
|
|
count: number;
|
|
start: string;
|
|
end: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new ContestRun(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.id = source["id"];
|
|
this.year = source["year"];
|
|
this.count = source["count"];
|
|
this.start = source["start"];
|
|
this.end = source["end"];
|
|
}
|
|
}
|
|
export class Gap {
|
|
start: string;
|
|
end: string;
|
|
minutes: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Gap(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.start = source["start"];
|
|
this.end = source["end"];
|
|
this.minutes = source["minutes"];
|
|
}
|
|
}
|
|
export class 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>;
|
|
award_refs?: 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.award_refs = source["award_refs"];
|
|
this.created_at = this.convertValues(source["created_at"], null);
|
|
this.updated_at = this.convertValues(source["updated_at"], null);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class QueryFilter {
|
|
quick_callsign?: string;
|
|
conditions?: Condition[];
|
|
match?: string;
|
|
limit?: number;
|
|
offset?: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new QueryFilter(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.quick_callsign = source["quick_callsign"];
|
|
this.conditions = this.convertValues(source["conditions"], Condition);
|
|
this.match = source["match"];
|
|
this.limit = source["limit"];
|
|
this.offset = source["offset"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class SlotStats {
|
|
slots_worked: number;
|
|
slots_confirmed: number;
|
|
dxcc_worked: number;
|
|
dxcc_confirmed: number;
|
|
ph_worked: number;
|
|
ph_confirmed: number;
|
|
cw_worked: number;
|
|
cw_confirmed: number;
|
|
dig_worked: number;
|
|
dig_confirmed: number;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new SlotStats(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.slots_worked = source["slots_worked"];
|
|
this.slots_confirmed = source["slots_confirmed"];
|
|
this.dxcc_worked = source["dxcc_worked"];
|
|
this.dxcc_confirmed = source["dxcc_confirmed"];
|
|
this.ph_worked = source["ph_worked"];
|
|
this.ph_confirmed = source["ph_confirmed"];
|
|
this.cw_worked = source["cw_worked"];
|
|
this.cw_confirmed = source["cw_confirmed"];
|
|
this.dig_worked = source["dig_worked"];
|
|
this.dig_confirmed = source["dig_confirmed"];
|
|
}
|
|
}
|
|
export class Stats {
|
|
total: number;
|
|
unique_calls: number;
|
|
entities: number;
|
|
continents: number;
|
|
first_qso: string;
|
|
last_qso: string;
|
|
confirmed_lotw: number;
|
|
confirmed_eqsl: number;
|
|
confirmed_qsl: number;
|
|
confirmed_any: number;
|
|
by_mode: Bucket[];
|
|
by_band: Bucket[];
|
|
by_band_category: BandCategory[];
|
|
by_operator: Bucket[];
|
|
by_station: Bucket[];
|
|
by_continent: Bucket[];
|
|
top_entities: Bucket[];
|
|
by_year: Bucket[];
|
|
by_month: Bucket[];
|
|
by_hour: Bucket[];
|
|
by_day7: Bucket[];
|
|
by_day30: Bucket[];
|
|
by_month12: Bucket[];
|
|
window_start: string;
|
|
window_end: string;
|
|
window_hours: number;
|
|
avg_per_hour: number;
|
|
avg_per_active: number;
|
|
on_air_minutes: number;
|
|
off_air_minutes: number;
|
|
peak_hour_key: string;
|
|
peak_hour_count: number;
|
|
best_60: number;
|
|
gaps: Gap[];
|
|
rate: Bucket[];
|
|
rate_ops: string[];
|
|
rate_by_op: number[][];
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Stats(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.total = source["total"];
|
|
this.unique_calls = source["unique_calls"];
|
|
this.entities = source["entities"];
|
|
this.continents = source["continents"];
|
|
this.first_qso = source["first_qso"];
|
|
this.last_qso = source["last_qso"];
|
|
this.confirmed_lotw = source["confirmed_lotw"];
|
|
this.confirmed_eqsl = source["confirmed_eqsl"];
|
|
this.confirmed_qsl = source["confirmed_qsl"];
|
|
this.confirmed_any = source["confirmed_any"];
|
|
this.by_mode = this.convertValues(source["by_mode"], Bucket);
|
|
this.by_band = this.convertValues(source["by_band"], Bucket);
|
|
this.by_band_category = this.convertValues(source["by_band_category"], BandCategory);
|
|
this.by_operator = this.convertValues(source["by_operator"], Bucket);
|
|
this.by_station = this.convertValues(source["by_station"], Bucket);
|
|
this.by_continent = this.convertValues(source["by_continent"], Bucket);
|
|
this.top_entities = this.convertValues(source["top_entities"], Bucket);
|
|
this.by_year = this.convertValues(source["by_year"], Bucket);
|
|
this.by_month = this.convertValues(source["by_month"], Bucket);
|
|
this.by_hour = this.convertValues(source["by_hour"], Bucket);
|
|
this.by_day7 = this.convertValues(source["by_day7"], Bucket);
|
|
this.by_day30 = this.convertValues(source["by_day30"], Bucket);
|
|
this.by_month12 = this.convertValues(source["by_month12"], Bucket);
|
|
this.window_start = source["window_start"];
|
|
this.window_end = source["window_end"];
|
|
this.window_hours = source["window_hours"];
|
|
this.avg_per_hour = source["avg_per_hour"];
|
|
this.avg_per_active = source["avg_per_active"];
|
|
this.on_air_minutes = source["on_air_minutes"];
|
|
this.off_air_minutes = source["off_air_minutes"];
|
|
this.peak_hour_key = source["peak_hour_key"];
|
|
this.peak_hour_count = source["peak_hour_count"];
|
|
this.best_60 = source["best_60"];
|
|
this.gaps = this.convertValues(source["gaps"], Gap);
|
|
this.rate = this.convertValues(source["rate"], Bucket);
|
|
this.rate_ops = source["rate_ops"];
|
|
this.rate_by_op = source["rate_by_op"];
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
export class WorkedBefore {
|
|
callsign: string;
|
|
count: number;
|
|
// Go type: time
|
|
first?: any;
|
|
// Go type: time
|
|
last?: any;
|
|
bands: string[];
|
|
modes: string[];
|
|
band_modes: BandMode[];
|
|
entries: QSO[];
|
|
dxcc?: number;
|
|
dxcc_name?: string;
|
|
dxcc_count: number;
|
|
// Go type: time
|
|
dxcc_first?: any;
|
|
// Go type: time
|
|
dxcc_last?: any;
|
|
dxcc_bands: string[];
|
|
dxcc_modes: string[];
|
|
dxcc_band_modes: BandMode[];
|
|
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 solar {
|
|
|
|
export class Data {
|
|
sfi: string;
|
|
ssn: string;
|
|
a_index: string;
|
|
k_index: string;
|
|
xray: string;
|
|
geomag_field: string;
|
|
aurora: string;
|
|
muf: string;
|
|
updated: string;
|
|
source: string;
|
|
ok: boolean;
|
|
error?: string;
|
|
// Go type: time
|
|
fetched_at: any;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Data(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.sfi = source["sfi"];
|
|
this.ssn = source["ssn"];
|
|
this.a_index = source["a_index"];
|
|
this.k_index = source["k_index"];
|
|
this.xray = source["xray"];
|
|
this.geomag_field = source["geomag_field"];
|
|
this.aurora = source["aurora"];
|
|
this.muf = source["muf"];
|
|
this.updated = source["updated"];
|
|
this.source = source["source"];
|
|
this.ok = source["ok"];
|
|
this.error = source["error"];
|
|
this.fetched_at = this.convertValues(source["fetched_at"], null);
|
|
}
|
|
|
|
convertValues(a: any, classs: any, asMap: boolean = false): any {
|
|
if (!a) {
|
|
return a;
|
|
}
|
|
if (a.slice && a.map) {
|
|
return (a as any[]).map(elem => this.convertValues(elem, classs));
|
|
} else if ("object" === typeof a) {
|
|
if (asMap) {
|
|
for (const key of Object.keys(a)) {
|
|
a[key] = new classs(a[key]);
|
|
}
|
|
return a;
|
|
}
|
|
return new classs(a);
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace spe {
|
|
|
|
export class Status {
|
|
connected: boolean;
|
|
last_error?: string;
|
|
model?: string;
|
|
operate: boolean;
|
|
tx: boolean;
|
|
input?: string;
|
|
band?: string;
|
|
power_level?: string;
|
|
output_w: number;
|
|
swr_atu: number;
|
|
swr_ant: number;
|
|
volt_pa: number;
|
|
curr_pa: number;
|
|
temp_c: number;
|
|
warnings?: string;
|
|
alarms?: string;
|
|
|
|
static createFrom(source: any = {}) {
|
|
return new Status(source);
|
|
}
|
|
|
|
constructor(source: any = {}) {
|
|
if ('string' === typeof source) source = JSON.parse(source);
|
|
this.connected = source["connected"];
|
|
this.last_error = source["last_error"];
|
|
this.model = source["model"];
|
|
this.operate = source["operate"];
|
|
this.tx = source["tx"];
|
|
this.input = source["input"];
|
|
this.band = source["band"];
|
|
this.power_level = source["power_level"];
|
|
this.output_w = source["output_w"];
|
|
this.swr_atu = source["swr_atu"];
|
|
this.swr_ant = source["swr_ant"];
|
|
this.volt_pa = source["volt_pa"];
|
|
this.curr_pa = source["curr_pa"];
|
|
this.temp_c = source["temp_c"];
|
|
this.warnings = source["warnings"];
|
|
this.alarms = source["alarms"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export namespace 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"];
|
|
}
|
|
}
|
|
|
|
}
|
|
|