import os
import json
import requests
from enum import Enum

class DataType(str, Enum):
    iq = 'iq'
    spectrogram = 'spectrogram'

class Format(str, Enum):
    blue = 'blue'
    matlab = 'matlab'
    raw = 'raw'
    sigmf = 'sigmf'
    vita49 = 'vita49'
    wav = 'wav'

class Precision(str, Enum):
    float32 = 'float32'
    float64 = 'float64'
    int16 = 'int16'
    int8 = 'int8'

class FrontEnd(str, Enum):
    front_end = 'front_end'

class Signal(str, Enum):
    acars = 'acars'
    acars_group = 'acars_group'
    acars_transmitter = 'acars_transmitter'
    adsb = 'adsb'
    adsb_group = 'adsb_group'
    adsb_transmitter = 'adsb_transmitter'
    ais_group = 'ais_group'
    ais_message = 'ais_message'
    ais_transmitter = 'ais_transmitter'
    am = 'am'
    am_group = 'am_group'
    aprs = 'aprs'
    aprs_group = 'aprs_group'
    aprs_transmitter = 'aprs_transmitter'
    apsk = 'apsk'
    ask = 'ask'
    ble = 'ble'
    ble_group = 'ble_group'
    ble_transmitter = 'ble_transmitter'
    chirp = 'chirp'
    cpfsk = 'cpfsk'
    dmr = 'dmr'
    dmr_group = 'dmr_group'
    dmr_transmitter = 'dmr_transmitter'
    dpsk = 'dpsk'
    dqpsk = 'dqpsk'
    dsss = 'dsss'
    fhss = 'fhss'
    fm = 'fm'
    fm_group = 'fm_group'
    fsk = 'fsk'
    gfsk = 'gfsk'
    gmsk = 'gmsk'
    gps = 'gps'
    gps_group = 'gps_group'
    gsm = 'gsm'
    gsm_group = 'gsm_group'
    gsm_transmitter = 'gsm_transmitter'
    iridium = 'iridium'
    iridium_group = 'iridium_group'
    iridium_handset = 'iridium_handset'
    iridium_satellite = 'iridium_satellite'
    lora = 'lora'
    lorawan = 'lorawan'
    lorawan_group = 'lorawan_group'
    lorawan_transmitter = 'lorawan_transmitter'
    meshcore = 'meshcore'
    meshcore_group = 'meshcore_group'
    meshcore_transmitter = 'meshcore_transmitter'
    meshtastic = 'meshtastic'
    meshtastic_group = 'meshtastic_group'
    meshtastic_transmitter = 'meshtastic_transmitter'
    msk = 'msk'
    ofdm = 'ofdm'
    ook = 'ook'
    p25 = 'p25'
    p25_group = 'p25_group'
    p25_transmitter = 'p25_transmitter'
    pam = 'pam'
    psk = 'psk'
    qam = 'qam'
    tetra = 'tetra'
    tetra_group = 'tetra_group'
    tetra_transmitter = 'tetra_transmitter'
    tone = 'tone'
    wifi = 'wifi'
    wifi_group = 'wifi_group'
    wifi_transmitter = 'wifi_transmitter'
    zigbee = 'zigbee'
    zigbee_group = 'zigbee_group'
    zigbee_transmitter = 'zigbee_transmitter'

class MessageType(str, Enum):
    airborne_position = 'airborne_position'
    airborne_velocity = 'airborne_velocity'
    aircraft_identification = 'aircraft_identification'
    surface_position = 'surface_position'

class FlightPhase(str, Enum):
    airborne = 'airborne'
    surface = 'surface'

class StationType(str, Enum):
    aton = 'aton'
    base_station = 'base_station'
    class_a = 'class_a'
    class_b = 'class_b'
    sar_aircraft = 'sar_aircraft'

class Message(str, Enum):
    multitone = 'multitone'
    random = 'random'
    tone = 'tone'

class InfoType(str, Enum):
    message = 'message'
    position = 'position'
    raw = 'raw'
    status = 'status'

class StationKind(str, Enum):
    digipeater = 'digipeater'
    home = 'home'
    igate = 'igate'
    mobile = 'mobile'

class PduType(str, Enum):
    adv_direct_ind = 'adv_direct_ind'
    adv_ind = 'adv_ind'
    adv_nonconn_ind = 'adv_nonconn_ind'
    scan_rsp = 'scan_rsp'

class AddressType(str, Enum):
    public = 'public'
    random = 'random'

class AdvertisingType(str, Enum):
    beacon = 'beacon'
    connectable = 'connectable'
    directed = 'directed'

class Waveform(str, Enum):
    barker = 'barker'
    fmcw_sawtooth = 'fmcw_sawtooth'
    fmcw_triangle = 'fmcw_triangle'
    linear = 'linear'

class Sequence(str, Enum):
    barker_11 = 'barker_11'
    barker_13 = 'barker_13'
    barker_2 = 'barker_2'
    barker_3 = 'barker_3'
    barker_4 = 'barker_4'
    barker_5 = 'barker_5'
    barker_7 = 'barker_7'
    custom = 'custom'
    gold_127 = 'gold_127'
    gold_31 = 'gold_31'
    gold_63 = 'gold_63'
    mseq_127 = 'mseq_127'
    mseq_15 = 'mseq_15'
    mseq_31 = 'mseq_31'
    mseq_63 = 'mseq_63'
    mseq_7 = 'mseq_7'

class BaseModulation(str, Enum):
    apsk = 'apsk'
    ask = 'ask'
    cpfsk = 'cpfsk'
    dpsk = 'dpsk'
    dqpsk = 'dqpsk'
    fsk = 'fsk'
    gfsk = 'gfsk'
    gmsk = 'gmsk'
    msk = 'msk'
    ook = 'ook'
    pam = 'pam'
    psk = 'psk'
    qam = 'qam'

class HopPattern(str, Enum):
    custom = 'custom'
    random = 'random'
    sequential = 'sequential'

class Activity(str, Enum):
    sbd = 'sbd'
    voice = 'voice'

class Protocol(str, Enum):
    lorawan = 'lorawan'
    meshcore = 'meshcore'
    meshtastic = 'meshtastic'
    raw = 'raw'

class Region(str, Enum):
    eu868 = 'eu868'
    us915 = 'us915'

class DeviceRole(str, Enum):
    end_device = 'end_device'
    router = 'router'

class MessageType2(str, Enum):
    msg14_safety_broadcast = 'msg14_safety_broadcast'
    msg18_position_report_class_b = 'msg18_position_report_class_b'
    msg1_position_report = 'msg1_position_report'
    msg21_aid_to_navigation = 'msg21_aid_to_navigation'
    msg24_static_data = 'msg24_static_data'
    msg27_long_range_broadcast = 'msg27_long_range_broadcast'
    msg28_aid_to_navigation_single_slot = 'msg28_aid_to_navigation_single_slot'
    msg2_assigned_position_report = 'msg2_assigned_position_report'
    msg3_special_position_report = 'msg3_special_position_report'
    msg4_base_station_report = 'msg4_base_station_report'
    msg5_static_voyage = 'msg5_static_voyage'
    msg9_sar_aircraft_position = 'msg9_sar_aircraft_position'

class Channel(str, Enum):
    duplex = 'duplex'
    simplex = 'simplex'

class DuplexDirection(str, Enum):
    downlink = 'downlink'
    uplink = 'uplink'

class DuplexDlType(str, Enum):
    da = 'da'
    ip = 'ip'
    sy = 'sy'
    vo = 'vo'

class DaSource(str, Enum):
    file = 'file'
    random = 'random'
    text = 'text'

class DuplexUlType(str, Enum):
    aq = 'aq'
    da = 'da'
    ip = 'ip'
    sy = 'sy'
    vo = 'vo'

class SimplexType(str, Enum):
    bc = 'bc'
    ms = 'ms'
    ra = 'ra'
    tl = 'tl'

class _BcAcars:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency='131550000, 130025000, 130425000, 130450000, 136700000, 136800000', baud=2400, samples_per_symbol=8, registration='.N123SG', acars_mode='2', label='H1', block_id='1', text='POS N37.6W122.4/ALT350/SIGTERA'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.registration = registration
        self.acars_mode = acars_mode
        self.label = label
        self.block_id = block_id
        self.text = text

    def to_dict(self):
        return {
            'signal': 'acars',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'registration': self.registration,
            'acars_mode': self.acars_mode,
            'label': self.label,
            'block_id': self.block_id,
            'text': self.text,
        }

class _BcAdsb:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, message_type=MessageType.aircraft_identification, icao='4840D6', latitude=37.7749, longitude=-122.4194, altitude=38000, surveillance_status=0, ground_speed=450, track=90.0, vertical_rate=0, callsign='SIGTERA1', category=0, movement=15.0):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.message_type = message_type
        self.icao = icao
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.surveillance_status = surveillance_status
        self.ground_speed = ground_speed
        self.track = track
        self.vertical_rate = vertical_rate
        self.callsign = callsign
        self.category = category
        self.movement = movement

    def to_dict(self):
        return {
            'signal': 'adsb',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'message_type': self.message_type,
            'icao': self.icao,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'surveillance_status': self.surveillance_status,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'vertical_rate': self.vertical_rate,
            'callsign': self.callsign,
            'category': self.category,
            'movement': self.movement,
        }

class _BcAis_message:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency='161975000, 162025000', baud=9600, samples_per_symbol=8, BT=0.4, message_type=MessageType2.msg1_position_report, mmsi=338000001, text='ALL CLEAR', lat=37.7749, lon=-122.4194, speed=0.0, course=0.0, heading=511, status=0, rot=-128, name='BUOY', aid_type=1, repeat=0, accuracy=0, to_bow=0, to_stern=0, to_port=0, to_starboard=0, epfd=0, second=60, off_position=0, reserved_1=0, raim=0, virtual_aid=0, assigned=0, name_ext='', shipname='SIGTERA', callsign='KXYZ', ship_type=0, station_type=1, restricted=0, iala_mrn=0, dimension=0, dimensions_a=0, dimensions_b=0, dimension_additional_data=0, charted_status=0, station_status=0, status_bits=0, auth=0, imo=0, month=0, day=0, hour=24, minute=60, draught=5.0, destination='', alt=1000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.message_type = message_type
        self.mmsi = mmsi
        self.text = text
        self.lat = lat
        self.lon = lon
        self.speed = speed
        self.course = course
        self.heading = heading
        self.status = status
        self.rot = rot
        self.name = name
        self.aid_type = aid_type
        self.repeat = repeat
        self.accuracy = accuracy
        self.to_bow = to_bow
        self.to_stern = to_stern
        self.to_port = to_port
        self.to_starboard = to_starboard
        self.epfd = epfd
        self.second = second
        self.off_position = off_position
        self.reserved_1 = reserved_1
        self.raim = raim
        self.virtual_aid = virtual_aid
        self.assigned = assigned
        self.name_ext = name_ext
        self.shipname = shipname
        self.callsign = callsign
        self.ship_type = ship_type
        self.station_type = station_type
        self.restricted = restricted
        self.iala_mrn = iala_mrn
        self.dimension = dimension
        self.dimensions_a = dimensions_a
        self.dimensions_b = dimensions_b
        self.dimension_additional_data = dimension_additional_data
        self.charted_status = charted_status
        self.station_status = station_status
        self.status_bits = status_bits
        self.auth = auth
        self.imo = imo
        self.month = month
        self.day = day
        self.hour = hour
        self.minute = minute
        self.draught = draught
        self.destination = destination
        self.alt = alt

    def to_dict(self):
        return {
            'signal': 'ais_message',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'message_type': self.message_type,
            'mmsi': self.mmsi,
            'text': self.text,
            'lat': self.lat,
            'lon': self.lon,
            'speed': self.speed,
            'course': self.course,
            'heading': self.heading,
            'status': self.status,
            'rot': self.rot,
            'name': self.name,
            'aid_type': self.aid_type,
            'repeat': self.repeat,
            'accuracy': self.accuracy,
            'to_bow': self.to_bow,
            'to_stern': self.to_stern,
            'to_port': self.to_port,
            'to_starboard': self.to_starboard,
            'epfd': self.epfd,
            'second': self.second,
            'off_position': self.off_position,
            'reserved_1': self.reserved_1,
            'raim': self.raim,
            'virtual_aid': self.virtual_aid,
            'assigned': self.assigned,
            'name_ext': self.name_ext,
            'shipname': self.shipname,
            'callsign': self.callsign,
            'ship_type': self.ship_type,
            'station_type': self.station_type,
            'restricted': self.restricted,
            'iala_mrn': self.iala_mrn,
            'dimension': self.dimension,
            'dimensions_a': self.dimensions_a,
            'dimensions_b': self.dimensions_b,
            'dimension_additional_data': self.dimension_additional_data,
            'charted_status': self.charted_status,
            'station_status': self.station_status,
            'status_bits': self.status_bits,
            'auth': self.auth,
            'imo': self.imo,
            'month': self.month,
            'day': self.day,
            'hour': self.hour,
            'minute': self.minute,
            'draught': self.draught,
            'destination': self.destination,
            'alt': self.alt,
        }

class _BcAM:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, duration=0.1, sideband='dsb', modulation_index=0.5, message_bandwidth=3000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.duration = duration
        self.sideband = sideband
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'am',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'duration': self.duration,
            'sideband': self.sideband,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
        }

class _BcAprs:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, info_type=InfoType.position, addressee='WB2OSZ', text='Hello', message_no='1', latitude=37.7749, longitude=-122.4194, symbol_table='/', symbol_code='>', course=-1, speed=-1, comment='Sigtera', info='>SIGTERA TEST', source='N0CALL', source_ssid=0, destination='APRS', path='WIDE1-1 WIDE2-2'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.info_type = info_type
        self.addressee = addressee
        self.text = text
        self.message_no = message_no
        self.latitude = latitude
        self.longitude = longitude
        self.symbol_table = symbol_table
        self.symbol_code = symbol_code
        self.course = course
        self.speed = speed
        self.comment = comment
        self.info = info
        self.source = source
        self.source_ssid = source_ssid
        self.destination = destination
        self.path = path

    def to_dict(self):
        return {
            'signal': 'aprs',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'info_type': self.info_type,
            'addressee': self.addressee,
            'text': self.text,
            'message_no': self.message_no,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'symbol_table': self.symbol_table,
            'symbol_code': self.symbol_code,
            'course': self.course,
            'speed': self.speed,
            'comment': self.comment,
            'info': self.info,
            'source': self.source,
            'source_ssid': self.source_ssid,
            'destination': self.destination,
            'path': self.path,
        }

class _BcApsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, modulation_order=16, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'apsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _BcASK:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, modulation_order=2, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ask',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _BcBLE:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=1000000, samples_per_symbol=8, BT=0.5, modulation_index=0.5, pdu_type=PduType.adv_ind, target_address='11:22:33:44:55:66', flags=6, device_name='Sigtera', manufacturer_data='', channel=37, advertiser_address='C0:FF:EE:C0:DE:01', address_type=AddressType.public):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index
        self.pdu_type = pdu_type
        self.target_address = target_address
        self.flags = flags
        self.device_name = device_name
        self.manufacturer_data = manufacturer_data
        self.channel = channel
        self.advertiser_address = advertiser_address
        self.address_type = address_type

    def to_dict(self):
        return {
            'signal': 'ble',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
            'pdu_type': self.pdu_type,
            'target_address': self.target_address,
            'flags': self.flags,
            'device_name': self.device_name,
            'manufacturer_data': self.manufacturer_data,
            'channel': self.channel,
            'advertiser_address': self.advertiser_address,
            'address_type': self.address_type,
        }

class _BcChirp:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, duration=0.001, bandwidth=10000, waveform=Waveform.linear, code_length='13', num_sweeps=8, direction='up'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.duration = duration
        self.bandwidth = bandwidth
        self.waveform = waveform
        self.code_length = code_length
        self.num_sweeps = num_sweeps
        self.direction = direction

    def to_dict(self):
        return {
            'signal': 'chirp',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'duration': self.duration,
            'bandwidth': self.bandwidth,
            'waveform': self.waveform,
            'code_length': self.code_length,
            'num_sweeps': self.num_sweeps,
            'direction': self.direction,
        }

class _BcCpfsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, modulation_order=2, baud=4800, samples_per_symbol=8, modulation_index=0.5):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'cpfsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
        }

class _BcDMR:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1296, content='voice'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.content = content

    def to_dict(self):
        return {
            'signal': 'dmr',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'content': self.content,
        }

class _BcDpsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dpsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
        }

class _BcDqpsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, baud=25000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dqpsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
        }

class _BcDsss:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_chip=1, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, sequence=Sequence.barker_13, code='0000011001010', base_modulation=BaseModulation.psk, modulation_order=16, baud=4800, samples_per_symbol=8, modulation_index=0.5, freq_sep=1000, BT=0.5):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_chip = samples_per_chip
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.sequence = sequence
        self.code = code
        self.base_modulation = base_modulation
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index
        self.freq_sep = freq_sep
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'dsss',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_chip': self.samples_per_chip,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'sequence': self.sequence,
            'code': self.code,
            'base_modulation': self.base_modulation,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
            'freq_sep': self.freq_sep,
            'BT': self.BT,
        }

class _BcFhss:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=4800, samples_per_symbol=8, freq_sep=2000, num_channels=8, channel_spacing=25000, hop_rate=100, hop_pattern=HopPattern.random, hop_sequence='0 3 1 2'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.num_channels = num_channels
        self.channel_spacing = channel_spacing
        self.hop_rate = hop_rate
        self.hop_pattern = hop_pattern
        self.hop_sequence = hop_sequence

    def to_dict(self):
        return {
            'signal': 'fhss',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'num_channels': self.num_channels,
            'channel_spacing': self.channel_spacing,
            'hop_rate': self.hop_rate,
            'hop_pattern': self.hop_pattern,
            'hop_sequence': self.hop_sequence,
        }

class _BcFM:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, duration=0.1, deviation=5000, message_bandwidth=3000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.duration = duration
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'fm',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'duration': self.duration,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
        }

class _BcFSK:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep

    def to_dict(self):
        return {
            'signal': 'fsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
        }

class _BcGfsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=4800, samples_per_symbol=8, BT=0.5, modulation_index=0.5):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'gfsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
        }

class _BcGmsk:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=9600, samples_per_symbol=8, BT=0.3):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'gmsk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
        }

class _BcGPS:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=1575420000, prn='1-32', doppler='-5000-5000', duration=0.02):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.prn = prn
        self.doppler = doppler
        self.duration = duration

    def to_dict(self):
        return {
            'signal': 'gps',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'prn': self.prn,
            'doppler': self.doppler,
            'duration': self.duration,
        }

class _BcGSM:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=270833.3333333333, samples_per_symbol=4, BT=0.3, burst_type='normal', tsc=0):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.burst_type = burst_type
        self.tsc = tsc

    def to_dict(self):
        return {
            'signal': 'gsm',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'burst_type': self.burst_type,
            'tsc': self.tsc,
        }

class _BcIridium:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, slot_index=0, snr=10, samples_per_symbol=10, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.4, baud=25000, channel=Channel.simplex, center_frequency=1621000000, duplex_direction=DuplexDirection.downlink, duplex_dl_type=DuplexDlType.vo, da_source=DaSource.text, da_file='', da_chars=10, da_text='SBD MSG', ip_source=DaSource.text, ip_file='', ip_chars=10, ip_text='ip payload', duplex_ul_type=DuplexUlType.aq, rid=42, simplex_type=SimplexType.ms, satellite=42, beam=12, iridium_time=1073741824, ms_source=DaSource.text, ms_file='', ms_chars=10, ms_text='HI', sat_x=1000, sat_y=1200, sat_z=800, tmsi='0x12345678', plane=1, message=1):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.slot_index = slot_index
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud
        self.channel = channel
        self.center_frequency = center_frequency
        self.duplex_direction = duplex_direction
        self.duplex_dl_type = duplex_dl_type
        self.da_source = da_source
        self.da_file = da_file
        self.da_chars = da_chars
        self.da_text = da_text
        self.ip_source = ip_source
        self.ip_file = ip_file
        self.ip_chars = ip_chars
        self.ip_text = ip_text
        self.duplex_ul_type = duplex_ul_type
        self.rid = rid
        self.simplex_type = simplex_type
        self.satellite = satellite
        self.beam = beam
        self.iridium_time = iridium_time
        self.ms_source = ms_source
        self.ms_file = ms_file
        self.ms_chars = ms_chars
        self.ms_text = ms_text
        self.sat_x = sat_x
        self.sat_y = sat_y
        self.sat_z = sat_z
        self.tmsi = tmsi
        self.plane = plane
        self.message = message

    def to_dict(self):
        return {
            'signal': 'iridium',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'slot_index': self.slot_index,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
            'channel': self.channel,
            'center_frequency': self.center_frequency,
            'duplex_direction': self.duplex_direction,
            'duplex_dl_type': self.duplex_dl_type,
            'da_source': self.da_source,
            'da_file': self.da_file,
            'da_chars': self.da_chars,
            'da_text': self.da_text,
            'ip_source': self.ip_source,
            'ip_file': self.ip_file,
            'ip_chars': self.ip_chars,
            'ip_text': self.ip_text,
            'duplex_ul_type': self.duplex_ul_type,
            'rid': self.rid,
            'simplex_type': self.simplex_type,
            'satellite': self.satellite,
            'beam': self.beam,
            'iridium_time': self.iridium_time,
            'ms_source': self.ms_source,
            'ms_file': self.ms_file,
            'ms_chars': self.ms_chars,
            'ms_text': self.ms_text,
            'sat_x': self.sat_x,
            'sat_y': self.sat_y,
            'sat_z': self.sat_z,
            'tmsi': self.tmsi,
            'plane': self.plane,
            'message': self.message,
        }

class _BcLora:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2, protocol=Protocol.raw, devaddr='26011BDA', fcnt=1, fport=1, app_payload='48656C6C6F', nwkskey='2B7E151628AED2A6ABF7158809CF4F3C', appskey='2B7E151628AED2A6ABF7158809CF4F3C', route_type=0, payload_type=1, mc_payload='48656C6C6F', dest='FFFFFFFF', sender='336A1B2C', packet_id='12345678', channel_hash=8, portnum=1, text='Hello Mesh', mt_payload=''):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling
        self.protocol = protocol
        self.devaddr = devaddr
        self.fcnt = fcnt
        self.fport = fport
        self.app_payload = app_payload
        self.nwkskey = nwkskey
        self.appskey = appskey
        self.route_type = route_type
        self.payload_type = payload_type
        self.mc_payload = mc_payload
        self.dest = dest
        self.sender = sender
        self.packet_id = packet_id
        self.channel_hash = channel_hash
        self.portnum = portnum
        self.text = text
        self.mt_payload = mt_payload

    def to_dict(self):
        return {
            'signal': 'lora',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
            'protocol': self.protocol,
            'devaddr': self.devaddr,
            'fcnt': self.fcnt,
            'fport': self.fport,
            'app_payload': self.app_payload,
            'nwkskey': self.nwkskey,
            'appskey': self.appskey,
            'route_type': self.route_type,
            'payload_type': self.payload_type,
            'mc_payload': self.mc_payload,
            'dest': self.dest,
            'sender': self.sender,
            'packet_id': self.packet_id,
            'channel_hash': self.channel_hash,
            'portnum': self.portnum,
            'text': self.text,
            'mt_payload': self.mt_payload,
        }

class _BcLorawan:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'lorawan',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _BcMeshcore:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshcore',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _BcMeshtastic:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshtastic',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _BcMSK:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, baud=4800, samples_per_symbol=8):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol

    def to_dict(self):
        return {
            'signal': 'msk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
        }

class _BcOfdm:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, modulation_order=2, num_subcarriers=64, fft_size=64, cyclic_prefix_length=16, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.num_subcarriers = num_subcarriers
        self.fft_size = fft_size
        self.cyclic_prefix_length = cyclic_prefix_length
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ofdm',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'num_subcarriers': self.num_subcarriers,
            'fft_size': self.fft_size,
            'cyclic_prefix_length': self.cyclic_prefix_length,
            'baud': self.baud,
        }

class _BcOOK:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ook',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
        }

class _BcP25:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1200, duid='voice_ldu1', nac=659):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.duid = duid
        self.nac = nac

    def to_dict(self):
        return {
            'signal': 'p25',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'duid': self.duid,
            'nac': self.nac,
        }

class _BcPAM:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, modulation_order=4, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'pam',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _BcPSK:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, modulation_order=4, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'psk',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _BcQAM:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, modulation_order=16, baud=4800):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'qam',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _BcTetra:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.35, baud=18000):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'tetra',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
        }

class _BcTone:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, duration=0.1, phase=0):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.duration = duration
        self.phase = phase

    def to_dict(self):
        return {
            'signal': 'tone',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'duration': self.duration,
            'phase': self.phase,
        }

class _BcWifi:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency=0, data_rate='36', psdu='0402002E006008CD37A60020D6013CF1006008AD3BAF00004A6F792C2062726967687420', scrambler_init=93):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.data_rate = data_rate
        self.psdu = psdu
        self.scrambler_init = scrambler_init

    def to_dict(self):
        return {
            'signal': 'wifi',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'data_rate': self.data_rate,
            'psdu': self.psdu,
            'scrambler_init': self.scrambler_init,
        }

class _BcZigbee:
    def __init__(self, count=1, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, upsample_ratio='2-8', pre_padding=0, post_padding=0, snr=10, center_frequency='2405000000:5000000:2480000000', channel=11, psdu='6188A1FFFF0000010203040506078F62'):
        self.count = count
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.upsample_ratio = upsample_ratio
        self.pre_padding = pre_padding
        self.post_padding = post_padding
        self.snr = snr
        self.center_frequency = center_frequency
        self.channel = channel
        self.psdu = psdu

    def to_dict(self):
        return {
            'signal': 'zigbee',
            'count': self.count,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'upsample_ratio': self.upsample_ratio,
            'pre-padding': self.pre_padding,
            'post-padding': self.post_padding,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'channel': self.channel,
            'psdu': self.psdu,
        }

class _WbAcars:
    def __init__(self, count=1, snr=10, center_frequency='131550000, 130025000, 130425000, 130450000, 136700000, 136800000', baud=2400, samples_per_symbol=8, signal_start_time=0, registration='.N123SG', acars_mode='2', label='H1', block_id='1', text='POS N37.6W122.4/ALT350/SIGTERA'):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.signal_start_time = signal_start_time
        self.registration = registration
        self.acars_mode = acars_mode
        self.label = label
        self.block_id = block_id
        self.text = text

    def to_dict(self):
        return {
            'signal': 'acars',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'signal_start_time': self.signal_start_time,
            'registration': self.registration,
            'acars_mode': self.acars_mode,
            'label': self.label,
            'block_id': self.block_id,
            'text': self.text,
        }

class _WbAcars_group:
    def __init__(self, count=1, signal_start_time=0, aircraft=6, center_frequency='131550000', center_lat=37.5, center_lon=-122.4, radius=200.0, altitude='1000-40000', ground_speed='150-500', report_interval='10-120', snr='5-30', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.aircraft = aircraft
        self.center_frequency = center_frequency
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'acars_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'aircraft': self.aircraft,
            'center_frequency': self.center_frequency,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _WbAcars_transmitter:
    def __init__(self, count=1, center_frequency='131550000, 130025000, 130425000, 130450000, 136700000, 136800000', signal_start_time=0, registration='.N123SG', flight='SG0123', acars_mode='2', latitude='36.5-38.5', longitude='-123.5--121.5', altitude='1000-40000', ground_speed='150-500', track='0-360', position_label='H1', report_interval='10-120', link_test_interval=0, free_text='', first_report=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.registration = registration
        self.flight = flight
        self.acars_mode = acars_mode
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.track = track
        self.position_label = position_label
        self.report_interval = report_interval
        self.link_test_interval = link_test_interval
        self.free_text = free_text
        self.first_report = first_report
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'acars_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'registration': self.registration,
            'flight': self.flight,
            'acars_mode': self.acars_mode,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'position_label': self.position_label,
            'report_interval': self.report_interval,
            'link_test_interval': self.link_test_interval,
            'free_text': self.free_text,
            'first_report': self.first_report,
            'snr': self.snr,
            'length': self.length,
        }

class _WbAdsb:
    def __init__(self, count=1, snr=10, message_type=MessageType.aircraft_identification, icao='4840D6', latitude=37.7749, longitude=-122.4194, altitude=38000, surveillance_status=0, ground_speed=450, track=90.0, vertical_rate=0, callsign='SIGTERA1', category=0, movement=15.0, center_frequency=0, signal_start_time=0):
        self.count = count
        self.snr = snr
        self.message_type = message_type
        self.icao = icao
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.surveillance_status = surveillance_status
        self.ground_speed = ground_speed
        self.track = track
        self.vertical_rate = vertical_rate
        self.callsign = callsign
        self.category = category
        self.movement = movement
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time

    def to_dict(self):
        return {
            'signal': 'adsb',
            'count': self.count,
            'snr': self.snr,
            'message_type': self.message_type,
            'icao': self.icao,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'surveillance_status': self.surveillance_status,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'vertical_rate': self.vertical_rate,
            'callsign': self.callsign,
            'category': self.category,
            'movement': self.movement,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
        }

class _WbAdsb_group:
    def __init__(self, count=1, signal_start_time=0, aircraft=8, ground_aircraft=0, center_lat=37.5, center_lon=-122.4, radius=100.0, altitude='1000-40000', ground_speed='150-500', vertical_rate='-1000-1000', taxi_speed='0-30', snr='5-30', center_frequency='1090000000', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.aircraft = aircraft
        self.ground_aircraft = ground_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.vertical_rate = vertical_rate
        self.taxi_speed = taxi_speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'adsb_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'aircraft': self.aircraft,
            'ground_aircraft': self.ground_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'vertical_rate': self.vertical_rate,
            'taxi_speed': self.taxi_speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _WbAdsb_transmitter:
    def __init__(self, count=1, center_frequency=1090000000, signal_start_time=0, icao='0x000001-0xFFFFFE', callsign='', category=0, latitude='36.5-38.5', longitude='-123.5--121.5', ground_speed='150-500', track='0-360', turn_rate=0, squitter_phase='0-0.5', snr='5-30', length=10, flight_phase=FlightPhase.airborne, altitude='1000-40000', vertical_rate='-1000-1000'):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.icao = icao
        self.callsign = callsign
        self.category = category
        self.latitude = latitude
        self.longitude = longitude
        self.ground_speed = ground_speed
        self.track = track
        self.turn_rate = turn_rate
        self.squitter_phase = squitter_phase
        self.snr = snr
        self.length = length
        self.flight_phase = flight_phase
        self.altitude = altitude
        self.vertical_rate = vertical_rate

    def to_dict(self):
        return {
            'signal': 'adsb_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'icao': self.icao,
            'callsign': self.callsign,
            'category': self.category,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'turn_rate': self.turn_rate,
            'squitter_phase': self.squitter_phase,
            'snr': self.snr,
            'length': self.length,
            'flight_phase': self.flight_phase,
            'altitude': self.altitude,
            'vertical_rate': self.vertical_rate,
        }

class _WbAis_group:
    def __init__(self, count=1, signal_start_time=0, vessels=8, class_b_vessels=0, base_stations=0, atons=0, sar_aircraft=0, center_lat=37.75, center_lon=-122.45, radius=10.0, speed='0-20', snr='5-30', center_frequency='161975000,162025000', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.vessels = vessels
        self.class_b_vessels = class_b_vessels
        self.base_stations = base_stations
        self.atons = atons
        self.sar_aircraft = sar_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ais_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'vessels': self.vessels,
            'class_b_vessels': self.class_b_vessels,
            'base_stations': self.base_stations,
            'atons': self.atons,
            'sar_aircraft': self.sar_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _WbAis_message:
    def __init__(self, count=1, snr=10, center_frequency='161975000, 162025000', baud=9600, samples_per_symbol=8, BT=0.4, signal_start_time=0, message_type=MessageType2.msg1_position_report, mmsi=338000001, text='ALL CLEAR', lat=37.7749, lon=-122.4194, speed=0.0, course=0.0, heading=511, status=0, rot=-128, name='BUOY', aid_type=1, repeat=0, accuracy=0, to_bow=0, to_stern=0, to_port=0, to_starboard=0, epfd=0, second=60, off_position=0, reserved_1=0, raim=0, virtual_aid=0, assigned=0, name_ext='', shipname='SIGTERA', callsign='KXYZ', ship_type=0, station_type=1, restricted=0, iala_mrn=0, dimension=0, dimensions_a=0, dimensions_b=0, dimension_additional_data=0, charted_status=0, station_status=0, status_bits=0, auth=0, imo=0, month=0, day=0, hour=24, minute=60, draught=5.0, destination='', alt=1000):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.signal_start_time = signal_start_time
        self.message_type = message_type
        self.mmsi = mmsi
        self.text = text
        self.lat = lat
        self.lon = lon
        self.speed = speed
        self.course = course
        self.heading = heading
        self.status = status
        self.rot = rot
        self.name = name
        self.aid_type = aid_type
        self.repeat = repeat
        self.accuracy = accuracy
        self.to_bow = to_bow
        self.to_stern = to_stern
        self.to_port = to_port
        self.to_starboard = to_starboard
        self.epfd = epfd
        self.second = second
        self.off_position = off_position
        self.reserved_1 = reserved_1
        self.raim = raim
        self.virtual_aid = virtual_aid
        self.assigned = assigned
        self.name_ext = name_ext
        self.shipname = shipname
        self.callsign = callsign
        self.ship_type = ship_type
        self.station_type = station_type
        self.restricted = restricted
        self.iala_mrn = iala_mrn
        self.dimension = dimension
        self.dimensions_a = dimensions_a
        self.dimensions_b = dimensions_b
        self.dimension_additional_data = dimension_additional_data
        self.charted_status = charted_status
        self.station_status = station_status
        self.status_bits = status_bits
        self.auth = auth
        self.imo = imo
        self.month = month
        self.day = day
        self.hour = hour
        self.minute = minute
        self.draught = draught
        self.destination = destination
        self.alt = alt

    def to_dict(self):
        return {
            'signal': 'ais_message',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'signal_start_time': self.signal_start_time,
            'message_type': self.message_type,
            'mmsi': self.mmsi,
            'text': self.text,
            'lat': self.lat,
            'lon': self.lon,
            'speed': self.speed,
            'course': self.course,
            'heading': self.heading,
            'status': self.status,
            'rot': self.rot,
            'name': self.name,
            'aid_type': self.aid_type,
            'repeat': self.repeat,
            'accuracy': self.accuracy,
            'to_bow': self.to_bow,
            'to_stern': self.to_stern,
            'to_port': self.to_port,
            'to_starboard': self.to_starboard,
            'epfd': self.epfd,
            'second': self.second,
            'off_position': self.off_position,
            'reserved_1': self.reserved_1,
            'raim': self.raim,
            'virtual_aid': self.virtual_aid,
            'assigned': self.assigned,
            'name_ext': self.name_ext,
            'shipname': self.shipname,
            'callsign': self.callsign,
            'ship_type': self.ship_type,
            'station_type': self.station_type,
            'restricted': self.restricted,
            'iala_mrn': self.iala_mrn,
            'dimension': self.dimension,
            'dimensions_a': self.dimensions_a,
            'dimensions_b': self.dimensions_b,
            'dimension_additional_data': self.dimension_additional_data,
            'charted_status': self.charted_status,
            'station_status': self.station_status,
            'status_bits': self.status_bits,
            'auth': self.auth,
            'imo': self.imo,
            'month': self.month,
            'day': self.day,
            'hour': self.hour,
            'minute': self.minute,
            'draught': self.draught,
            'destination': self.destination,
            'alt': self.alt,
        }

class _WbAis_transmitter:
    def __init__(self, count=1, center_frequency='161975000, 162025000', signal_start_time=0, latitude='37.0-38.0', longitude='-123.0--122.0', slot='0-2249', static_phase='0-360', snr='5-30', length=10, station_type=StationType.class_a, mmsi='992000000-997999999', aton_name='BUOY', aid_type=1, virtual_aid=0, speed='0-25', course='0-360', heading=511, rate_of_turn=0, nav_status=0, ship_name='SIGTERA', callsign='KXYZ', ship_type=70, imo=0, destination='', draught=5.0, to_bow=50, to_stern=20, to_port=5, to_starboard=5, altitude='150-1500'):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.latitude = latitude
        self.longitude = longitude
        self.slot = slot
        self.static_phase = static_phase
        self.snr = snr
        self.length = length
        self.station_type = station_type
        self.mmsi = mmsi
        self.aton_name = aton_name
        self.aid_type = aid_type
        self.virtual_aid = virtual_aid
        self.speed = speed
        self.course = course
        self.heading = heading
        self.rate_of_turn = rate_of_turn
        self.nav_status = nav_status
        self.ship_name = ship_name
        self.callsign = callsign
        self.ship_type = ship_type
        self.imo = imo
        self.destination = destination
        self.draught = draught
        self.to_bow = to_bow
        self.to_stern = to_stern
        self.to_port = to_port
        self.to_starboard = to_starboard
        self.altitude = altitude

    def to_dict(self):
        return {
            'signal': 'ais_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'slot': self.slot,
            'static_phase': self.static_phase,
            'snr': self.snr,
            'length': self.length,
            'station_type': self.station_type,
            'mmsi': self.mmsi,
            'aton_name': self.aton_name,
            'aid_type': self.aid_type,
            'virtual_aid': self.virtual_aid,
            'speed': self.speed,
            'course': self.course,
            'heading': self.heading,
            'rate_of_turn': self.rate_of_turn,
            'nav_status': self.nav_status,
            'ship_name': self.ship_name,
            'callsign': self.callsign,
            'ship_type': self.ship_type,
            'imo': self.imo,
            'destination': self.destination,
            'draught': self.draught,
            'to_bow': self.to_bow,
            'to_stern': self.to_stern,
            'to_port': self.to_port,
            'to_starboard': self.to_starboard,
            'altitude': self.altitude,
        }

class _WbAM:
    def __init__(self, count=1, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, signal_start_time=0, duration=0.1, sideband='dsb', modulation_index=0.5, message_bandwidth=3000):
        self.count = count
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.duration = duration
        self.sideband = sideband
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'am',
            'count': self.count,
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'duration': self.duration,
            'sideband': self.sideband,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
        }

class _WbAm_group:
    def __init__(self, count=1, signal_start_time=0, stations=8, center_frequency='540000:10000:1700000', modulation_index=0.8, message_bandwidth=5000, snr='5-30', length=1):
        self.count = count
        self.signal_start_time = signal_start_time
        self.stations = stations
        self.center_frequency = center_frequency
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'am_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _WbAprs:
    def __init__(self, count=1, snr=10, info_type=InfoType.position, addressee='WB2OSZ', text='Hello', message_no='1', latitude=37.7749, longitude=-122.4194, symbol_table='/', symbol_code='>', course=-1, speed=-1, comment='Sigtera', info='>SIGTERA TEST', center_frequency=0, signal_start_time=0, source='N0CALL', source_ssid=0, destination='APRS', path='WIDE1-1 WIDE2-2'):
        self.count = count
        self.snr = snr
        self.info_type = info_type
        self.addressee = addressee
        self.text = text
        self.message_no = message_no
        self.latitude = latitude
        self.longitude = longitude
        self.symbol_table = symbol_table
        self.symbol_code = symbol_code
        self.course = course
        self.speed = speed
        self.comment = comment
        self.info = info
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.source = source
        self.source_ssid = source_ssid
        self.destination = destination
        self.path = path

    def to_dict(self):
        return {
            'signal': 'aprs',
            'count': self.count,
            'snr': self.snr,
            'info_type': self.info_type,
            'addressee': self.addressee,
            'text': self.text,
            'message_no': self.message_no,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'symbol_table': self.symbol_table,
            'symbol_code': self.symbol_code,
            'course': self.course,
            'speed': self.speed,
            'comment': self.comment,
            'info': self.info,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'source': self.source,
            'source_ssid': self.source_ssid,
            'destination': self.destination,
            'path': self.path,
        }

class _WbAprs_group:
    def __init__(self, count=1, signal_start_time=0, mobiles=6, home_stations=1, digipeaters=1, igates=0, center_lat=37.75, center_lon=-122.45, radius=30.0, speed='0-60', beacon_interval='600-1800', snr='5-30', center_frequency='144390000', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.mobiles = mobiles
        self.home_stations = home_stations
        self.digipeaters = digipeaters
        self.igates = igates
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.beacon_interval = beacon_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'aprs_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'mobiles': self.mobiles,
            'home_stations': self.home_stations,
            'digipeaters': self.digipeaters,
            'igates': self.igates,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'beacon_interval': self.beacon_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _WbAprs_transmitter:
    def __init__(self, count=1, center_frequency=144390000, signal_start_time=0, source='SIGTRA', source_ssid='0-15', destination='APRS', path='WIDE1-1 WIDE2-2', latitude='37.0-38.0', longitude='-123.0--122.0', comment='Sigtera', status_text='', status_interval=600, first_beacon=0, snr='5-30', length=10, station_kind=StationKind.mobile, beacon_interval='600-1800', speed='0-60', course='0-360', turn_rate=0, fast_rate=90, slow_rate=1800, fast_speed=52, slow_speed=4, turn_angle=28, turn_slope=255, turn_time=15):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.source = source
        self.source_ssid = source_ssid
        self.destination = destination
        self.path = path
        self.latitude = latitude
        self.longitude = longitude
        self.comment = comment
        self.status_text = status_text
        self.status_interval = status_interval
        self.first_beacon = first_beacon
        self.snr = snr
        self.length = length
        self.station_kind = station_kind
        self.beacon_interval = beacon_interval
        self.speed = speed
        self.course = course
        self.turn_rate = turn_rate
        self.fast_rate = fast_rate
        self.slow_rate = slow_rate
        self.fast_speed = fast_speed
        self.slow_speed = slow_speed
        self.turn_angle = turn_angle
        self.turn_slope = turn_slope
        self.turn_time = turn_time

    def to_dict(self):
        return {
            'signal': 'aprs_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'source': self.source,
            'source_ssid': self.source_ssid,
            'destination': self.destination,
            'path': self.path,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'comment': self.comment,
            'status_text': self.status_text,
            'status_interval': self.status_interval,
            'first_beacon': self.first_beacon,
            'snr': self.snr,
            'length': self.length,
            'station_kind': self.station_kind,
            'beacon_interval': self.beacon_interval,
            'speed': self.speed,
            'course': self.course,
            'turn_rate': self.turn_rate,
            'fast_rate': self.fast_rate,
            'slow_rate': self.slow_rate,
            'fast_speed': self.fast_speed,
            'slow_speed': self.slow_speed,
            'turn_angle': self.turn_angle,
            'turn_slope': self.turn_slope,
            'turn_time': self.turn_time,
        }

class _WbApsk:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, modulation_order=16, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'apsk',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _WbASK:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, modulation_order=2, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ask',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _WbBLE:
    def __init__(self, count=1, snr=10, center_frequency=0, baud=1000000, samples_per_symbol=8, BT=0.5, modulation_index=0.5, pdu_type=PduType.adv_ind, target_address='11:22:33:44:55:66', flags=6, device_name='Sigtera', manufacturer_data='', signal_start_time=0, channel=37, advertiser_address='C0:FF:EE:C0:DE:01', address_type=AddressType.public):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index
        self.pdu_type = pdu_type
        self.target_address = target_address
        self.flags = flags
        self.device_name = device_name
        self.manufacturer_data = manufacturer_data
        self.signal_start_time = signal_start_time
        self.channel = channel
        self.advertiser_address = advertiser_address
        self.address_type = address_type

    def to_dict(self):
        return {
            'signal': 'ble',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
            'pdu_type': self.pdu_type,
            'target_address': self.target_address,
            'flags': self.flags,
            'device_name': self.device_name,
            'manufacturer_data': self.manufacturer_data,
            'signal_start_time': self.signal_start_time,
            'channel': self.channel,
            'advertiser_address': self.advertiser_address,
            'address_type': self.address_type,
        }

class _WbBle_group:
    def __init__(self, count=1, signal_start_time=0, devices=8, beacons=4, directed=0, advertising_interval='0.05-1.0', beacon_uuid='E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', major=1, snr='5-30', center_frequency='2402000000', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.beacons = beacons
        self.directed = directed
        self.advertising_interval = advertising_interval
        self.beacon_uuid = beacon_uuid
        self.major = major
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ble_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'beacons': self.beacons,
            'directed': self.directed,
            'advertising_interval': self.advertising_interval,
            'beacon_uuid': self.beacon_uuid,
            'major': self.major,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _WbBle_transmitter:
    def __init__(self, count=1, center_frequency=2402000000.0, signal_start_time=0, advertiser_address='C0:FF:EE:C0:DE:01', address_type=AddressType.public, advertising_interval='0.1-1.0', channel_map='37,38,39', first_event=0, snr='5-30', length=10, advertising_type=AdvertisingType.connectable, beacon_uuid='E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', major=1, minor='1-65535', measured_power=-59, device_name='Sigtera', flags=6, manufacturer_data='', scan_probability=0, target_address='11:22:33:44:55:66'):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.advertiser_address = advertiser_address
        self.address_type = address_type
        self.advertising_interval = advertising_interval
        self.channel_map = channel_map
        self.first_event = first_event
        self.snr = snr
        self.length = length
        self.advertising_type = advertising_type
        self.beacon_uuid = beacon_uuid
        self.major = major
        self.minor = minor
        self.measured_power = measured_power
        self.device_name = device_name
        self.flags = flags
        self.manufacturer_data = manufacturer_data
        self.scan_probability = scan_probability
        self.target_address = target_address

    def to_dict(self):
        return {
            'signal': 'ble_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'advertiser_address': self.advertiser_address,
            'address_type': self.address_type,
            'advertising_interval': self.advertising_interval,
            'channel_map': self.channel_map,
            'first_event': self.first_event,
            'snr': self.snr,
            'length': self.length,
            'advertising_type': self.advertising_type,
            'beacon_uuid': self.beacon_uuid,
            'major': self.major,
            'minor': self.minor,
            'measured_power': self.measured_power,
            'device_name': self.device_name,
            'flags': self.flags,
            'manufacturer_data': self.manufacturer_data,
            'scan_probability': self.scan_probability,
            'target_address': self.target_address,
        }

class _WbChirp:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, duration=0.001, bandwidth=10000, waveform=Waveform.linear, code_length='13', num_sweeps=8, direction='up'):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.duration = duration
        self.bandwidth = bandwidth
        self.waveform = waveform
        self.code_length = code_length
        self.num_sweeps = num_sweeps
        self.direction = direction

    def to_dict(self):
        return {
            'signal': 'chirp',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'duration': self.duration,
            'bandwidth': self.bandwidth,
            'waveform': self.waveform,
            'code_length': self.code_length,
            'num_sweeps': self.num_sweeps,
            'direction': self.direction,
        }

class _WbCpfsk:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, modulation_order=2, baud=4800, samples_per_symbol=8, modulation_index=0.5):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'cpfsk',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
        }

class _WbDMR:
    def __init__(self, count=1, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1296, signal_start_time=0, content='voice'):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.signal_start_time = signal_start_time
        self.content = content

    def to_dict(self):
        return {
            'signal': 'dmr',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'signal_start_time': self.signal_start_time,
            'content': self.content,
        }

class _WbDmr_group:
    def __init__(self, count=1, signal_start_time=0, repeaters=4, center_frequency='451000000:12500:452987500', call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.repeaters = repeaters
        self.center_frequency = center_frequency
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'dmr_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'repeaters': self.repeaters,
            'center_frequency': self.center_frequency,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _WbDmr_transmitter:
    def __init__(self, count=1, center_frequency='136000000:12500:173987500, 400000000:12500:469987500', signal_start_time=0, color_code=1, talkgroup='1-65535', active_slots=2, call_duration='2-8', idle='1-10', hang_time=2, first_call=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.color_code = color_code
        self.talkgroup = talkgroup
        self.active_slots = active_slots
        self.call_duration = call_duration
        self.idle = idle
        self.hang_time = hang_time
        self.first_call = first_call
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'dmr_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'color_code': self.color_code,
            'talkgroup': self.talkgroup,
            'active_slots': self.active_slots,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'hang_time': self.hang_time,
            'first_call': self.first_call,
            'snr': self.snr,
            'length': self.length,
        }

class _WbDpsk:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dpsk',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
        }

class _WbDqpsk:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, baud=25000):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dqpsk',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
        }

class _WbDsss:
    def __init__(self, count=1, snr=10, samples_per_chip=1, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, sequence=Sequence.barker_13, code='0000011001010', base_modulation=BaseModulation.psk, modulation_order=16, baud=4800, samples_per_symbol=8, modulation_index=0.5, freq_sep=1000, BT=0.5):
        self.count = count
        self.snr = snr
        self.samples_per_chip = samples_per_chip
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.sequence = sequence
        self.code = code
        self.base_modulation = base_modulation
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index
        self.freq_sep = freq_sep
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'dsss',
            'count': self.count,
            'snr': self.snr,
            'samples_per_chip': self.samples_per_chip,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'sequence': self.sequence,
            'code': self.code,
            'base_modulation': self.base_modulation,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
            'freq_sep': self.freq_sep,
            'BT': self.BT,
        }

class _WbFhss:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, baud=4800, samples_per_symbol=8, freq_sep=2000, num_channels=8, channel_spacing=25000, hop_rate=100, hop_pattern=HopPattern.random, hop_sequence='0 3 1 2'):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.num_channels = num_channels
        self.channel_spacing = channel_spacing
        self.hop_rate = hop_rate
        self.hop_pattern = hop_pattern
        self.hop_sequence = hop_sequence

    def to_dict(self):
        return {
            'signal': 'fhss',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'num_channels': self.num_channels,
            'channel_spacing': self.channel_spacing,
            'hop_rate': self.hop_rate,
            'hop_pattern': self.hop_pattern,
            'hop_sequence': self.hop_sequence,
        }

class _WbFM:
    def __init__(self, count=1, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, signal_start_time=0, duration=0.1, deviation=5000, message_bandwidth=3000):
        self.count = count
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.duration = duration
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'fm',
            'count': self.count,
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'duration': self.duration,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
        }

class _WbFm_group:
    def __init__(self, count=1, signal_start_time=0, stations=8, center_frequency='88100000:200000:107900000', deviation=75000, message_bandwidth=15000, snr='5-30', length=1):
        self.count = count
        self.signal_start_time = signal_start_time
        self.stations = stations
        self.center_frequency = center_frequency
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'fm_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _WbFSK:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1000):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep

    def to_dict(self):
        return {
            'signal': 'fsk',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
        }

class _WbGfsk:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, baud=4800, samples_per_symbol=8, BT=0.5, modulation_index=0.5):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'gfsk',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
        }

class _WbGmsk:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, baud=9600, samples_per_symbol=8, BT=0.3):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'gmsk',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
        }

class _WbGPS:
    def __init__(self, count=1, snr=10, center_frequency=1575420000, signal_start_time=0, prn='1-32', doppler='-5000-5000', duration=0.02):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.prn = prn
        self.doppler = doppler
        self.duration = duration

    def to_dict(self):
        return {
            'signal': 'gps',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'prn': self.prn,
            'doppler': self.doppler,
            'duration': self.duration,
        }

class _WbGps_group:
    def __init__(self, count=1, signal_start_time=0, satellites=8, prn='1:1:32', center_frequency='1575420000', doppler='-5000-5000', snr='5-30', length=0.02):
        self.count = count
        self.signal_start_time = signal_start_time
        self.satellites = satellites
        self.prn = prn
        self.center_frequency = center_frequency
        self.doppler = doppler
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gps_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'satellites': self.satellites,
            'prn': self.prn,
            'center_frequency': self.center_frequency,
            'doppler': self.doppler,
            'snr': self.snr,
            'length': self.length,
        }

class _WbGSM:
    def __init__(self, count=1, snr=10, center_frequency=0, baud=270833.3333333333, samples_per_symbol=4, BT=0.3, signal_start_time=0, burst_type='normal', tsc=0):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.signal_start_time = signal_start_time
        self.burst_type = burst_type
        self.tsc = tsc

    def to_dict(self):
        return {
            'signal': 'gsm',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'signal_start_time': self.signal_start_time,
            'burst_type': self.burst_type,
            'tsc': self.tsc,
        }

class _WbGsm_group:
    def __init__(self, count=1, signal_start_time=0, cells=6, center_frequency='935200000:200000:959800000', ncc=0, busy_timeslots='0,1,2,3,4,5,6,7', snr='5-30', length=1):
        self.count = count
        self.signal_start_time = signal_start_time
        self.cells = cells
        self.center_frequency = center_frequency
        self.ncc = ncc
        self.busy_timeslots = busy_timeslots
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gsm_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'cells': self.cells,
            'center_frequency': self.center_frequency,
            'ncc': self.ncc,
            'busy_timeslots': self.busy_timeslots,
            'snr': self.snr,
            'length': self.length,
        }

class _WbGsm_transmitter:
    def __init__(self, count=1, center_frequency='935200000:200000:959800000', signal_start_time=0, ncc=0, bcc='0,1,2,3,4,5,6,7', frame_number='0-2715647', busy_timeslots='0,1,2,3,4,5,6,7', snr='5-30', length=1):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.ncc = ncc
        self.bcc = bcc
        self.frame_number = frame_number
        self.busy_timeslots = busy_timeslots
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gsm_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'ncc': self.ncc,
            'bcc': self.bcc,
            'frame_number': self.frame_number,
            'busy_timeslots': self.busy_timeslots,
            'snr': self.snr,
            'length': self.length,
        }

class _WbIridium:
    def __init__(self, count=1, slot_index=0, snr=10, samples_per_symbol=10, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.4, baud=25000, signal_start_time=0, channel=Channel.simplex, center_frequency=1621000000, duplex_direction=DuplexDirection.downlink, duplex_dl_type=DuplexDlType.vo, da_source=DaSource.text, da_file='', da_chars=10, da_text='SBD MSG', ip_source=DaSource.text, ip_file='', ip_chars=10, ip_text='ip payload', duplex_ul_type=DuplexUlType.aq, rid=42, simplex_type=SimplexType.ms, satellite=42, beam=12, iridium_time=1073741824, ms_source=DaSource.text, ms_file='', ms_chars=10, ms_text='HI', sat_x=1000, sat_y=1200, sat_z=800, tmsi='0x12345678', plane=1, message=1):
        self.count = count
        self.slot_index = slot_index
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud
        self.signal_start_time = signal_start_time
        self.channel = channel
        self.center_frequency = center_frequency
        self.duplex_direction = duplex_direction
        self.duplex_dl_type = duplex_dl_type
        self.da_source = da_source
        self.da_file = da_file
        self.da_chars = da_chars
        self.da_text = da_text
        self.ip_source = ip_source
        self.ip_file = ip_file
        self.ip_chars = ip_chars
        self.ip_text = ip_text
        self.duplex_ul_type = duplex_ul_type
        self.rid = rid
        self.simplex_type = simplex_type
        self.satellite = satellite
        self.beam = beam
        self.iridium_time = iridium_time
        self.ms_source = ms_source
        self.ms_file = ms_file
        self.ms_chars = ms_chars
        self.ms_text = ms_text
        self.sat_x = sat_x
        self.sat_y = sat_y
        self.sat_z = sat_z
        self.tmsi = tmsi
        self.plane = plane
        self.message = message

    def to_dict(self):
        return {
            'signal': 'iridium',
            'count': self.count,
            'slot_index': self.slot_index,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
            'signal_start_time': self.signal_start_time,
            'channel': self.channel,
            'center_frequency': self.center_frequency,
            'duplex_direction': self.duplex_direction,
            'duplex_dl_type': self.duplex_dl_type,
            'da_source': self.da_source,
            'da_file': self.da_file,
            'da_chars': self.da_chars,
            'da_text': self.da_text,
            'ip_source': self.ip_source,
            'ip_file': self.ip_file,
            'ip_chars': self.ip_chars,
            'ip_text': self.ip_text,
            'duplex_ul_type': self.duplex_ul_type,
            'rid': self.rid,
            'simplex_type': self.simplex_type,
            'satellite': self.satellite,
            'beam': self.beam,
            'iridium_time': self.iridium_time,
            'ms_source': self.ms_source,
            'ms_file': self.ms_file,
            'ms_chars': self.ms_chars,
            'ms_text': self.ms_text,
            'sat_x': self.sat_x,
            'sat_y': self.sat_y,
            'sat_z': self.sat_z,
            'tmsi': self.tmsi,
            'plane': self.plane,
            'message': self.message,
        }

class _WbIridium_group:
    def __init__(self, count=1, signal_start_time=0, satellites=6, handsets=2, satellite='1:1:66', center_lat=37.5, center_lon=-122.4, radius=2500.0, beam='1-48', beacon_interval='1-4', broadcast_interval=4.32, iridium_time=1073741824, session_interval='3-8', snr='5-30', center_frequency='1626270833', uplink_frequency='1616020833:41667:1626437500', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.satellites = satellites
        self.handsets = handsets
        self.satellite = satellite
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.beam = beam
        self.beacon_interval = beacon_interval
        self.broadcast_interval = broadcast_interval
        self.iridium_time = iridium_time
        self.session_interval = session_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.uplink_frequency = uplink_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'iridium_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'satellites': self.satellites,
            'handsets': self.handsets,
            'satellite': self.satellite,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'beam': self.beam,
            'beacon_interval': self.beacon_interval,
            'broadcast_interval': self.broadcast_interval,
            'iridium_time': self.iridium_time,
            'session_interval': self.session_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'uplink_frequency': self.uplink_frequency,
            'length': self.length,
        }

class _WbIridium_handset:
    def __init__(self, count=1, center_frequency='1616020833:41667:1626437500', signal_start_time=0, tmsi='0x00000001-0xFFFFFFFE', uplink_slot='2,3,4,5', session_interval='3-8', session_offset='0-2', snr='5-30', length=10, activity=Activity.sbd, sbd_text='SBD MSG', call_length='1-3'):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.tmsi = tmsi
        self.uplink_slot = uplink_slot
        self.session_interval = session_interval
        self.session_offset = session_offset
        self.snr = snr
        self.length = length
        self.activity = activity
        self.sbd_text = sbd_text
        self.call_length = call_length

    def to_dict(self):
        return {
            'signal': 'iridium_handset',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'tmsi': self.tmsi,
            'uplink_slot': self.uplink_slot,
            'session_interval': self.session_interval,
            'session_offset': self.session_offset,
            'snr': self.snr,
            'length': self.length,
            'activity': self.activity,
            'sbd_text': self.sbd_text,
            'call_length': self.call_length,
        }

class _WbIridium_satellite:
    def __init__(self, count=1, center_frequency=1626270833, signal_start_time=0, satellite='1-66', beam='1-48', plane='1,2,3,4,5,6', orbit_slot='1,2,3,4,5,6,7,8,9,10,11', latitude='-60-60', longitude='-180-180', direction='ascending,descending', altitude=780, inclination=86.4, tmsi='0x12345678', iridium_time=1073741824, beacon_interval=1.0, broadcast_interval=4.32, time_location_interval=0, beacon_offset=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.satellite = satellite
        self.beam = beam
        self.plane = plane
        self.orbit_slot = orbit_slot
        self.latitude = latitude
        self.longitude = longitude
        self.direction = direction
        self.altitude = altitude
        self.inclination = inclination
        self.tmsi = tmsi
        self.iridium_time = iridium_time
        self.beacon_interval = beacon_interval
        self.broadcast_interval = broadcast_interval
        self.time_location_interval = time_location_interval
        self.beacon_offset = beacon_offset
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'iridium_satellite',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'satellite': self.satellite,
            'beam': self.beam,
            'plane': self.plane,
            'orbit_slot': self.orbit_slot,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'direction': self.direction,
            'altitude': self.altitude,
            'inclination': self.inclination,
            'tmsi': self.tmsi,
            'iridium_time': self.iridium_time,
            'beacon_interval': self.beacon_interval,
            'broadcast_interval': self.broadcast_interval,
            'time_location_interval': self.time_location_interval,
            'beacon_offset': self.beacon_offset,
            'snr': self.snr,
            'length': self.length,
        }

class _WbLora:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2, protocol=Protocol.raw, devaddr='26011BDA', fcnt=1, fport=1, app_payload='48656C6C6F', nwkskey='2B7E151628AED2A6ABF7158809CF4F3C', appskey='2B7E151628AED2A6ABF7158809CF4F3C', route_type=0, payload_type=1, mc_payload='48656C6C6F', dest='FFFFFFFF', sender='336A1B2C', packet_id='12345678', channel_hash=8, portnum=1, text='Hello Mesh', mt_payload=''):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling
        self.protocol = protocol
        self.devaddr = devaddr
        self.fcnt = fcnt
        self.fport = fport
        self.app_payload = app_payload
        self.nwkskey = nwkskey
        self.appskey = appskey
        self.route_type = route_type
        self.payload_type = payload_type
        self.mc_payload = mc_payload
        self.dest = dest
        self.sender = sender
        self.packet_id = packet_id
        self.channel_hash = channel_hash
        self.portnum = portnum
        self.text = text
        self.mt_payload = mt_payload

    def to_dict(self):
        return {
            'signal': 'lora',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
            'protocol': self.protocol,
            'devaddr': self.devaddr,
            'fcnt': self.fcnt,
            'fport': self.fport,
            'app_payload': self.app_payload,
            'nwkskey': self.nwkskey,
            'appskey': self.appskey,
            'route_type': self.route_type,
            'payload_type': self.payload_type,
            'mc_payload': self.mc_payload,
            'dest': self.dest,
            'sender': self.sender,
            'packet_id': self.packet_id,
            'channel_hash': self.channel_hash,
            'portnum': self.portnum,
            'text': self.text,
            'mt_payload': self.mt_payload,
        }

class _WbLorawan:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'lorawan',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _WbLorawan_group:
    def __init__(self, count=1, center_frequency=0, signal_start_time=0, devices=6, tx_interval='5-60', spreading_factor='7,8,9,10', snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.tx_interval = tx_interval
        self.spreading_factor = spreading_factor
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'lorawan_group',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'tx_interval': self.tx_interval,
            'spreading_factor': self.spreading_factor,
            'snr': self.snr,
            'length': self.length,
        }

class _WbLorawan_transmitter:
    def __init__(self, count=1, signal_start_time=0, devaddr='0x26000001-0x27FFFFFE', nwkskey='2B7E151628AED2A6ABF7158809CF4F3C', appskey='2B7E151628AED2A6ABF7158809CF4F3C', fcnt='0-1000', fport=1, app_payload='48656C6C6F', spreading_factor='7,8,9,10', tx_interval='5-60', tx_phase=0, snr='5-30', length=10, region=Region.us915, center_frequency=868100000, sub_band=2):
        self.count = count
        self.signal_start_time = signal_start_time
        self.devaddr = devaddr
        self.nwkskey = nwkskey
        self.appskey = appskey
        self.fcnt = fcnt
        self.fport = fport
        self.app_payload = app_payload
        self.spreading_factor = spreading_factor
        self.tx_interval = tx_interval
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length
        self.region = region
        self.center_frequency = center_frequency
        self.sub_band = sub_band

    def to_dict(self):
        return {
            'signal': 'lorawan_transmitter',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'devaddr': self.devaddr,
            'nwkskey': self.nwkskey,
            'appskey': self.appskey,
            'fcnt': self.fcnt,
            'fport': self.fport,
            'app_payload': self.app_payload,
            'spreading_factor': self.spreading_factor,
            'tx_interval': self.tx_interval,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
            'region': self.region,
            'center_frequency': self.center_frequency,
            'sub_band': self.sub_band,
        }

class _WbMeshcore:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshcore',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _WbMeshcore_group:
    def __init__(self, count=1, center_frequency=0, signal_start_time=0, devices=6, repeaters=1, center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.repeaters = repeaters
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshcore_group',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'repeaters': self.repeaters,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _WbMeshcore_transmitter:
    def __init__(self, count=1, center_frequency=910525000, signal_start_time=0, node_id='0x00000001-0xFFFFFFFE', node_name='Sigtera', node_type='chat', latitude='37.0-38.0', longitude='-123.0--122.0', advert_interval=3600, timestamp=1790000000, tx_phase=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.node_id = node_id
        self.node_name = node_name
        self.node_type = node_type
        self.latitude = latitude
        self.longitude = longitude
        self.advert_interval = advert_interval
        self.timestamp = timestamp
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshcore_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'node_id': self.node_id,
            'node_name': self.node_name,
            'node_type': self.node_type,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'advert_interval': self.advert_interval,
            'timestamp': self.timestamp,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
        }

class _WbMeshtastic:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshtastic',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _WbMeshtastic_group:
    def __init__(self, count=1, center_frequency=0, signal_start_time=0, devices=6, modem_preset='long_fast', center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.modem_preset = modem_preset
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshtastic_group',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'modem_preset': self.modem_preset,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _WbMeshtastic_transmitter:
    def __init__(self, count=1, center_frequency=906875000, signal_start_time=0, sender='0x00000001-0xFFFFFFFE', long_name='Sigtera Node', short_name='SIG', modem_preset='long_fast', latitude='37.0-38.0', longitude='-123.0--122.0', altitude='0-500', position_interval=900, nodeinfo_interval=10800, text='', packet_id='0x00000001-0x7FFFFFFF', tx_phase=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.sender = sender
        self.long_name = long_name
        self.short_name = short_name
        self.modem_preset = modem_preset
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.position_interval = position_interval
        self.nodeinfo_interval = nodeinfo_interval
        self.text = text
        self.packet_id = packet_id
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshtastic_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'sender': self.sender,
            'long_name': self.long_name,
            'short_name': self.short_name,
            'modem_preset': self.modem_preset,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'position_interval': self.position_interval,
            'nodeinfo_interval': self.nodeinfo_interval,
            'text': self.text,
            'packet_id': self.packet_id,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
        }

class _WbMSK:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, baud=4800, samples_per_symbol=8):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol

    def to_dict(self):
        return {
            'signal': 'msk',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
        }

class _WbOfdm:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, modulation_order=2, num_subcarriers=64, fft_size=64, cyclic_prefix_length=16, baud=4800):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.num_subcarriers = num_subcarriers
        self.fft_size = fft_size
        self.cyclic_prefix_length = cyclic_prefix_length
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ofdm',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'num_subcarriers': self.num_subcarriers,
            'fft_size': self.fft_size,
            'cyclic_prefix_length': self.cyclic_prefix_length,
            'baud': self.baud,
        }

class _WbOOK:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ook',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
        }

class _WbP25:
    def __init__(self, count=1, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1200, signal_start_time=0, duid='voice_ldu1', nac=659):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.signal_start_time = signal_start_time
        self.duid = duid
        self.nac = nac

    def to_dict(self):
        return {
            'signal': 'p25',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'signal_start_time': self.signal_start_time,
            'duid': self.duid,
            'nac': self.nac,
        }

class _WbP25_group:
    def __init__(self, count=1, signal_start_time=0, channels=4, center_frequency='769000000:12500:774987500', nac=659, call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.channels = channels
        self.center_frequency = center_frequency
        self.nac = nac
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'p25_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'channels': self.channels,
            'center_frequency': self.center_frequency,
            'nac': self.nac,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _WbP25_transmitter:
    def __init__(self, count=1, center_frequency='769000000:12500:774987500', signal_start_time=0, role='traffic', nac=659, talkgroup='1-65535', call_duration='2-8', idle='1-10', first_call=0, snr='5-30', length=10):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.role = role
        self.nac = nac
        self.talkgroup = talkgroup
        self.call_duration = call_duration
        self.idle = idle
        self.first_call = first_call
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'p25_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'role': self.role,
            'nac': self.nac,
            'talkgroup': self.talkgroup,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'first_call': self.first_call,
            'snr': self.snr,
            'length': self.length,
        }

class _WbPAM:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, modulation_order=4, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'pam',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _WbPSK:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, modulation_order=4, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'psk',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _WbQAM:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, modulation_order=16, baud=4800):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'qam',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _WbTetra:
    def __init__(self, count=1, snr=10, samples_per_symbol=8, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency=0, signal_start_time=0, baud=18000):
        self.count = count
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'tetra',
            'count': self.count,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'baud': self.baud,
        }

class _WbTetra_group:
    def __init__(self, count=1, signal_start_time=0, carriers=3, center_frequency='390000000:25000:391975000', mcc=901, mnc=1, colour_code='1-63', call_duration='2-8', idle='1-10', snr='5-30', length=1):
        self.count = count
        self.signal_start_time = signal_start_time
        self.carriers = carriers
        self.center_frequency = center_frequency
        self.mcc = mcc
        self.mnc = mnc
        self.colour_code = colour_code
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'tetra_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'carriers': self.carriers,
            'center_frequency': self.center_frequency,
            'mcc': self.mcc,
            'mnc': self.mnc,
            'colour_code': self.colour_code,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _WbTetra_transmitter:
    def __init__(self, count=1, samples_per_symbol=8, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.35, center_frequency='390000000:25000:399975000', signal_start_time=0, mcc=901, mnc=1, colour_code='1-63', carrier_number='0-4095', carrier_role='main', call_duration='2-8', idle='1-10', baud=18000, snr='5-30', length=1):
        self.count = count
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.mcc = mcc
        self.mnc = mnc
        self.colour_code = colour_code
        self.carrier_number = carrier_number
        self.carrier_role = carrier_role
        self.call_duration = call_duration
        self.idle = idle
        self.baud = baud
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'tetra_transmitter',
            'count': self.count,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'mcc': self.mcc,
            'mnc': self.mnc,
            'colour_code': self.colour_code,
            'carrier_number': self.carrier_number,
            'carrier_role': self.carrier_role,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'baud': self.baud,
            'snr': self.snr,
            'length': self.length,
        }

class _WbTone:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, duration=0.1, phase=0):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.duration = duration
        self.phase = phase

    def to_dict(self):
        return {
            'signal': 'tone',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'duration': self.duration,
            'phase': self.phase,
        }

class _WbWifi:
    def __init__(self, count=1, snr=10, center_frequency=0, signal_start_time=0, data_rate='36', psdu='0402002E006008CD37A60020D6013CF1006008AD3BAF00004A6F792C2062726967687420', scrambler_init=93):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.data_rate = data_rate
        self.psdu = psdu
        self.scrambler_init = scrambler_init

    def to_dict(self):
        return {
            'signal': 'wifi',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'data_rate': self.data_rate,
            'psdu': self.psdu,
            'scrambler_init': self.scrambler_init,
        }

class _WbWifi_group:
    def __init__(self, count=1, signal_start_time=0, access_points=4, center_frequency='5180000000:20000000:5825000000', beacon_interval=0.1024, traffic='0-20', snr='5-30', length=1):
        self.count = count
        self.signal_start_time = signal_start_time
        self.access_points = access_points
        self.center_frequency = center_frequency
        self.beacon_interval = beacon_interval
        self.traffic = traffic
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'wifi_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'access_points': self.access_points,
            'center_frequency': self.center_frequency,
            'beacon_interval': self.beacon_interval,
            'traffic': self.traffic,
            'snr': self.snr,
            'length': self.length,
        }

class _WbWifi_transmitter:
    def __init__(self, count=1, center_frequency='5180000000:20000000:5825000000', signal_start_time=0, ssid='SIGTERA', bssid='1-16777214', beacon_interval=0.1024, traffic='0-20', uptime='0-86400', sequence_start='0-4095', data_rate='36', snr='5-30', length=1):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.ssid = ssid
        self.bssid = bssid
        self.beacon_interval = beacon_interval
        self.traffic = traffic
        self.uptime = uptime
        self.sequence_start = sequence_start
        self.data_rate = data_rate
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'wifi_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'ssid': self.ssid,
            'bssid': self.bssid,
            'beacon_interval': self.beacon_interval,
            'traffic': self.traffic,
            'uptime': self.uptime,
            'sequence_start': self.sequence_start,
            'data_rate': self.data_rate,
            'snr': self.snr,
            'length': self.length,
        }

class _WbZigbee:
    def __init__(self, count=1, snr=10, center_frequency='2405000000:5000000:2480000000', signal_start_time=0, channel=11, psdu='6188A1FFFF0000010203040506078F62'):
        self.count = count
        self.snr = snr
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.channel = channel
        self.psdu = psdu

    def to_dict(self):
        return {
            'signal': 'zigbee',
            'count': self.count,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'channel': self.channel,
            'psdu': self.psdu,
        }

class _WbZigbee_group:
    def __init__(self, count=1, signal_start_time=0, end_devices=5, routers=1, channel=11, pan_id='0x1A62', center_frequency='2405000000', report_interval='0.5-10', snr='5-30', length=10):
        self.count = count
        self.signal_start_time = signal_start_time
        self.end_devices = end_devices
        self.routers = routers
        self.channel = channel
        self.pan_id = pan_id
        self.center_frequency = center_frequency
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'zigbee_group',
            'count': self.count,
            'signal_start_time': self.signal_start_time,
            'end_devices': self.end_devices,
            'routers': self.routers,
            'channel': self.channel,
            'pan_id': self.pan_id,
            'center_frequency': self.center_frequency,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _WbZigbee_transmitter:
    def __init__(self, count=1, center_frequency='2405000000:5000000:2480000000', signal_start_time=0, channel=11, pan_id='0x1A62', short_address='1-65534', parent_address=0, sequence_start='0-255', payload='0102030405060708', report_interval='0.5-10', first_report=0, snr='5-30', length=10, device_role=DeviceRole.end_device, poll_interval=7.5):
        self.count = count
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.channel = channel
        self.pan_id = pan_id
        self.short_address = short_address
        self.parent_address = parent_address
        self.sequence_start = sequence_start
        self.payload = payload
        self.report_interval = report_interval
        self.first_report = first_report
        self.snr = snr
        self.length = length
        self.device_role = device_role
        self.poll_interval = poll_interval

    def to_dict(self):
        return {
            'signal': 'zigbee_transmitter',
            'count': self.count,
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'channel': self.channel,
            'pan_id': self.pan_id,
            'short_address': self.short_address,
            'parent_address': self.parent_address,
            'sequence_start': self.sequence_start,
            'payload': self.payload,
            'report_interval': self.report_interval,
            'first_report': self.first_report,
            'snr': self.snr,
            'length': self.length,
            'device_role': self.device_role,
            'poll_interval': self.poll_interval,
        }

class _BasebandCuts:
    def __init__(self, seed='0-4294967295', data_type=DataType.iq, format=Format.raw, precision=Precision.float32):
        self.seed = seed
        self.data_type = data_type
        self.format = format
        self.precision = precision
        self._signals = []

    def Acars(self, **kwargs):
        sig = _BcAcars(**kwargs)
        self._signals.append(sig)
        return sig

    def Adsb(self, **kwargs):
        sig = _BcAdsb(**kwargs)
        self._signals.append(sig)
        return sig

    def Ais_message(self, **kwargs):
        sig = _BcAis_message(**kwargs)
        self._signals.append(sig)
        return sig

    def AM(self, **kwargs):
        sig = _BcAM(**kwargs)
        self._signals.append(sig)
        return sig

    def Aprs(self, **kwargs):
        sig = _BcAprs(**kwargs)
        self._signals.append(sig)
        return sig

    def Apsk(self, **kwargs):
        sig = _BcApsk(**kwargs)
        self._signals.append(sig)
        return sig

    def ASK(self, **kwargs):
        sig = _BcASK(**kwargs)
        self._signals.append(sig)
        return sig

    def BLE(self, **kwargs):
        sig = _BcBLE(**kwargs)
        self._signals.append(sig)
        return sig

    def Chirp(self, **kwargs):
        sig = _BcChirp(**kwargs)
        self._signals.append(sig)
        return sig

    def Cpfsk(self, **kwargs):
        sig = _BcCpfsk(**kwargs)
        self._signals.append(sig)
        return sig

    def DMR(self, **kwargs):
        sig = _BcDMR(**kwargs)
        self._signals.append(sig)
        return sig

    def Dpsk(self, **kwargs):
        sig = _BcDpsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Dqpsk(self, **kwargs):
        sig = _BcDqpsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Dsss(self, **kwargs):
        sig = _BcDsss(**kwargs)
        self._signals.append(sig)
        return sig

    def Fhss(self, **kwargs):
        sig = _BcFhss(**kwargs)
        self._signals.append(sig)
        return sig

    def FM(self, **kwargs):
        sig = _BcFM(**kwargs)
        self._signals.append(sig)
        return sig

    def FSK(self, **kwargs):
        sig = _BcFSK(**kwargs)
        self._signals.append(sig)
        return sig

    def Gfsk(self, **kwargs):
        sig = _BcGfsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Gmsk(self, **kwargs):
        sig = _BcGmsk(**kwargs)
        self._signals.append(sig)
        return sig

    def GPS(self, **kwargs):
        sig = _BcGPS(**kwargs)
        self._signals.append(sig)
        return sig

    def GSM(self, **kwargs):
        sig = _BcGSM(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium(self, **kwargs):
        sig = _BcIridium(**kwargs)
        self._signals.append(sig)
        return sig

    def Lora(self, **kwargs):
        sig = _BcLora(**kwargs)
        self._signals.append(sig)
        return sig

    def Lorawan(self, **kwargs):
        sig = _BcLorawan(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshcore(self, **kwargs):
        sig = _BcMeshcore(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshtastic(self, **kwargs):
        sig = _BcMeshtastic(**kwargs)
        self._signals.append(sig)
        return sig

    def MSK(self, **kwargs):
        sig = _BcMSK(**kwargs)
        self._signals.append(sig)
        return sig

    def Ofdm(self, **kwargs):
        sig = _BcOfdm(**kwargs)
        self._signals.append(sig)
        return sig

    def OOK(self, **kwargs):
        sig = _BcOOK(**kwargs)
        self._signals.append(sig)
        return sig

    def P25(self, **kwargs):
        sig = _BcP25(**kwargs)
        self._signals.append(sig)
        return sig

    def PAM(self, **kwargs):
        sig = _BcPAM(**kwargs)
        self._signals.append(sig)
        return sig

    def PSK(self, **kwargs):
        sig = _BcPSK(**kwargs)
        self._signals.append(sig)
        return sig

    def QAM(self, **kwargs):
        sig = _BcQAM(**kwargs)
        self._signals.append(sig)
        return sig

    def Tetra(self, **kwargs):
        sig = _BcTetra(**kwargs)
        self._signals.append(sig)
        return sig

    def Tone(self, **kwargs):
        sig = _BcTone(**kwargs)
        self._signals.append(sig)
        return sig

    def Wifi(self, **kwargs):
        sig = _BcWifi(**kwargs)
        self._signals.append(sig)
        return sig

    def Zigbee(self, **kwargs):
        sig = _BcZigbee(**kwargs)
        self._signals.append(sig)
        return sig
    def to_dict(self):
        return {
            'mode': 'dataset_generation',
            'segmentation': 'baseband_cuts',
            'seed': self.seed,
            'data_type': self.data_type,
            'format': self.format,
            'precision': self.precision,
            'signal': [s.to_dict() for s in self._signals],
        }

class _Wideband:
    def __init__(self, seed='0-4294967295', data_type=DataType.iq, format=Format.raw, precision=Precision.float32, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, length=10, acquisition_frequency=0, sample_rate=100000):
        self.seed = seed
        self.data_type = data_type
        self.format = format
        self.precision = precision
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.length = length
        self.acquisition_frequency = acquisition_frequency
        self.sample_rate = sample_rate
        self._signals = []

    def Acars(self, **kwargs):
        sig = _WbAcars(**kwargs)
        self._signals.append(sig)
        return sig

    def Acars_group(self, **kwargs):
        sig = _WbAcars_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Acars_transmitter(self, **kwargs):
        sig = _WbAcars_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Adsb(self, **kwargs):
        sig = _WbAdsb(**kwargs)
        self._signals.append(sig)
        return sig

    def Adsb_group(self, **kwargs):
        sig = _WbAdsb_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Adsb_transmitter(self, **kwargs):
        sig = _WbAdsb_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Ais_group(self, **kwargs):
        sig = _WbAis_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Ais_message(self, **kwargs):
        sig = _WbAis_message(**kwargs)
        self._signals.append(sig)
        return sig

    def Ais_transmitter(self, **kwargs):
        sig = _WbAis_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def AM(self, **kwargs):
        sig = _WbAM(**kwargs)
        self._signals.append(sig)
        return sig

    def Am_group(self, **kwargs):
        sig = _WbAm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Aprs(self, **kwargs):
        sig = _WbAprs(**kwargs)
        self._signals.append(sig)
        return sig

    def Aprs_group(self, **kwargs):
        sig = _WbAprs_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Aprs_transmitter(self, **kwargs):
        sig = _WbAprs_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Apsk(self, **kwargs):
        sig = _WbApsk(**kwargs)
        self._signals.append(sig)
        return sig

    def ASK(self, **kwargs):
        sig = _WbASK(**kwargs)
        self._signals.append(sig)
        return sig

    def BLE(self, **kwargs):
        sig = _WbBLE(**kwargs)
        self._signals.append(sig)
        return sig

    def Ble_group(self, **kwargs):
        sig = _WbBle_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Ble_transmitter(self, **kwargs):
        sig = _WbBle_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Chirp(self, **kwargs):
        sig = _WbChirp(**kwargs)
        self._signals.append(sig)
        return sig

    def Cpfsk(self, **kwargs):
        sig = _WbCpfsk(**kwargs)
        self._signals.append(sig)
        return sig

    def DMR(self, **kwargs):
        sig = _WbDMR(**kwargs)
        self._signals.append(sig)
        return sig

    def Dmr_group(self, **kwargs):
        sig = _WbDmr_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Dmr_transmitter(self, **kwargs):
        sig = _WbDmr_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Dpsk(self, **kwargs):
        sig = _WbDpsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Dqpsk(self, **kwargs):
        sig = _WbDqpsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Dsss(self, **kwargs):
        sig = _WbDsss(**kwargs)
        self._signals.append(sig)
        return sig

    def Fhss(self, **kwargs):
        sig = _WbFhss(**kwargs)
        self._signals.append(sig)
        return sig

    def FM(self, **kwargs):
        sig = _WbFM(**kwargs)
        self._signals.append(sig)
        return sig

    def Fm_group(self, **kwargs):
        sig = _WbFm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def FSK(self, **kwargs):
        sig = _WbFSK(**kwargs)
        self._signals.append(sig)
        return sig

    def Gfsk(self, **kwargs):
        sig = _WbGfsk(**kwargs)
        self._signals.append(sig)
        return sig

    def Gmsk(self, **kwargs):
        sig = _WbGmsk(**kwargs)
        self._signals.append(sig)
        return sig

    def GPS(self, **kwargs):
        sig = _WbGPS(**kwargs)
        self._signals.append(sig)
        return sig

    def Gps_group(self, **kwargs):
        sig = _WbGps_group(**kwargs)
        self._signals.append(sig)
        return sig

    def GSM(self, **kwargs):
        sig = _WbGSM(**kwargs)
        self._signals.append(sig)
        return sig

    def Gsm_group(self, **kwargs):
        sig = _WbGsm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Gsm_transmitter(self, **kwargs):
        sig = _WbGsm_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium(self, **kwargs):
        sig = _WbIridium(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium_group(self, **kwargs):
        sig = _WbIridium_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium_handset(self, **kwargs):
        sig = _WbIridium_handset(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium_satellite(self, **kwargs):
        sig = _WbIridium_satellite(**kwargs)
        self._signals.append(sig)
        return sig

    def Lora(self, **kwargs):
        sig = _WbLora(**kwargs)
        self._signals.append(sig)
        return sig

    def Lorawan(self, **kwargs):
        sig = _WbLorawan(**kwargs)
        self._signals.append(sig)
        return sig

    def Lorawan_group(self, **kwargs):
        sig = _WbLorawan_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Lorawan_transmitter(self, **kwargs):
        sig = _WbLorawan_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshcore(self, **kwargs):
        sig = _WbMeshcore(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshcore_group(self, **kwargs):
        sig = _WbMeshcore_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshcore_transmitter(self, **kwargs):
        sig = _WbMeshcore_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshtastic(self, **kwargs):
        sig = _WbMeshtastic(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshtastic_group(self, **kwargs):
        sig = _WbMeshtastic_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshtastic_transmitter(self, **kwargs):
        sig = _WbMeshtastic_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def MSK(self, **kwargs):
        sig = _WbMSK(**kwargs)
        self._signals.append(sig)
        return sig

    def Ofdm(self, **kwargs):
        sig = _WbOfdm(**kwargs)
        self._signals.append(sig)
        return sig

    def OOK(self, **kwargs):
        sig = _WbOOK(**kwargs)
        self._signals.append(sig)
        return sig

    def P25(self, **kwargs):
        sig = _WbP25(**kwargs)
        self._signals.append(sig)
        return sig

    def P25_group(self, **kwargs):
        sig = _WbP25_group(**kwargs)
        self._signals.append(sig)
        return sig

    def P25_transmitter(self, **kwargs):
        sig = _WbP25_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def PAM(self, **kwargs):
        sig = _WbPAM(**kwargs)
        self._signals.append(sig)
        return sig

    def PSK(self, **kwargs):
        sig = _WbPSK(**kwargs)
        self._signals.append(sig)
        return sig

    def QAM(self, **kwargs):
        sig = _WbQAM(**kwargs)
        self._signals.append(sig)
        return sig

    def Tetra(self, **kwargs):
        sig = _WbTetra(**kwargs)
        self._signals.append(sig)
        return sig

    def Tetra_group(self, **kwargs):
        sig = _WbTetra_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Tetra_transmitter(self, **kwargs):
        sig = _WbTetra_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Tone(self, **kwargs):
        sig = _WbTone(**kwargs)
        self._signals.append(sig)
        return sig

    def Wifi(self, **kwargs):
        sig = _WbWifi(**kwargs)
        self._signals.append(sig)
        return sig

    def Wifi_group(self, **kwargs):
        sig = _WbWifi_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Wifi_transmitter(self, **kwargs):
        sig = _WbWifi_transmitter(**kwargs)
        self._signals.append(sig)
        return sig

    def Zigbee(self, **kwargs):
        sig = _WbZigbee(**kwargs)
        self._signals.append(sig)
        return sig

    def Zigbee_group(self, **kwargs):
        sig = _WbZigbee_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Zigbee_transmitter(self, **kwargs):
        sig = _WbZigbee_transmitter(**kwargs)
        self._signals.append(sig)
        return sig
    def to_dict(self):
        return {
            'mode': 'dataset_generation',
            'segmentation': 'wideband',
            'seed': self.seed,
            'data_type': self.data_type,
            'format': self.format,
            'precision': self.precision,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'length': self.length,
            'acquisition_frequency': self.acquisition_frequency,
            'sample_rate': self.sample_rate,
            'signal': [s.to_dict() for s in self._signals],
        }

class _EnvTxAcars:
    def __init__(self, snr=10, center_frequency='131550000, 130025000, 130425000, 130450000, 136700000, 136800000', baud=2400, samples_per_symbol=8, transmitter_start_time=0, count=1, registration='.N123SG', acars_mode='2', label='H1', block_id='1', text='POS N37.6W122.4/ALT350/SIGTERA'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.registration = registration
        self.acars_mode = acars_mode
        self.label = label
        self.block_id = block_id
        self.text = text

    def to_dict(self):
        return {
            'signal': 'acars',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'registration': self.registration,
            'acars_mode': self.acars_mode,
            'label': self.label,
            'block_id': self.block_id,
            'text': self.text,
        }

class _EnvTxAcars_group:
    def __init__(self, transmitter_start_time=0, count=1, aircraft=6, center_frequency='131550000', center_lat=37.5, center_lon=-122.4, radius=200.0, altitude='1000-40000', ground_speed='150-500', report_interval='10-120', snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.aircraft = aircraft
        self.center_frequency = center_frequency
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'acars_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'aircraft': self.aircraft,
            'center_frequency': self.center_frequency,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxAcars_transmitter:
    def __init__(self, center_frequency='131550000, 130025000, 130425000, 130450000, 136700000, 136800000', transmitter_start_time=0, count=1, registration='.N123SG', flight='SG0123', acars_mode='2', latitude='36.5-38.5', longitude='-123.5--121.5', altitude='1000-40000', ground_speed='150-500', track='0-360', position_label='H1', report_interval='10-120', link_test_interval=0, free_text='', first_report=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.registration = registration
        self.flight = flight
        self.acars_mode = acars_mode
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.track = track
        self.position_label = position_label
        self.report_interval = report_interval
        self.link_test_interval = link_test_interval
        self.free_text = free_text
        self.first_report = first_report
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'acars_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'registration': self.registration,
            'flight': self.flight,
            'acars_mode': self.acars_mode,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'position_label': self.position_label,
            'report_interval': self.report_interval,
            'link_test_interval': self.link_test_interval,
            'free_text': self.free_text,
            'first_report': self.first_report,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxAdsb:
    def __init__(self, snr=10, center_frequency=0, message_type=MessageType.aircraft_identification, icao='4840D6', latitude=37.7749, longitude=-122.4194, altitude=38000, surveillance_status=0, ground_speed=450, track=90.0, vertical_rate=0, callsign='SIGTERA1', category=0, movement=15.0, transmitter_start_time=0, count=1):
        self.snr = snr
        self.center_frequency = center_frequency
        self.message_type = message_type
        self.icao = icao
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.surveillance_status = surveillance_status
        self.ground_speed = ground_speed
        self.track = track
        self.vertical_rate = vertical_rate
        self.callsign = callsign
        self.category = category
        self.movement = movement
        self.transmitter_start_time = transmitter_start_time
        self.count = count

    def to_dict(self):
        return {
            'signal': 'adsb',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'message_type': self.message_type,
            'icao': self.icao,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'surveillance_status': self.surveillance_status,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'vertical_rate': self.vertical_rate,
            'callsign': self.callsign,
            'category': self.category,
            'movement': self.movement,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
        }

class _EnvTxAdsb_group:
    def __init__(self, transmitter_start_time=0, count=1, aircraft=8, ground_aircraft=0, center_lat=37.5, center_lon=-122.4, radius=100.0, altitude='1000-40000', ground_speed='150-500', vertical_rate='-1000-1000', taxi_speed='0-30', snr='5-30', center_frequency='1090000000', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.aircraft = aircraft
        self.ground_aircraft = ground_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.vertical_rate = vertical_rate
        self.taxi_speed = taxi_speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'adsb_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'aircraft': self.aircraft,
            'ground_aircraft': self.ground_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'vertical_rate': self.vertical_rate,
            'taxi_speed': self.taxi_speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _EnvTxAdsb_transmitter:
    def __init__(self, center_frequency=1090000000, transmitter_start_time=0, count=1, icao='0x000001-0xFFFFFE', callsign='', category=0, latitude='36.5-38.5', longitude='-123.5--121.5', ground_speed='150-500', track='0-360', turn_rate=0, squitter_phase='0-0.5', snr='5-30', length=10, flight_phase=FlightPhase.airborne, altitude='1000-40000', vertical_rate='-1000-1000'):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.icao = icao
        self.callsign = callsign
        self.category = category
        self.latitude = latitude
        self.longitude = longitude
        self.ground_speed = ground_speed
        self.track = track
        self.turn_rate = turn_rate
        self.squitter_phase = squitter_phase
        self.snr = snr
        self.length = length
        self.flight_phase = flight_phase
        self.altitude = altitude
        self.vertical_rate = vertical_rate

    def to_dict(self):
        return {
            'signal': 'adsb_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'icao': self.icao,
            'callsign': self.callsign,
            'category': self.category,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'ground_speed': self.ground_speed,
            'track': self.track,
            'turn_rate': self.turn_rate,
            'squitter_phase': self.squitter_phase,
            'snr': self.snr,
            'length': self.length,
            'flight_phase': self.flight_phase,
            'altitude': self.altitude,
            'vertical_rate': self.vertical_rate,
        }

class _EnvTxAis_group:
    def __init__(self, transmitter_start_time=0, count=1, vessels=8, class_b_vessels=0, base_stations=0, atons=0, sar_aircraft=0, center_lat=37.75, center_lon=-122.45, radius=10.0, speed='0-20', snr='5-30', center_frequency='161975000,162025000', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.vessels = vessels
        self.class_b_vessels = class_b_vessels
        self.base_stations = base_stations
        self.atons = atons
        self.sar_aircraft = sar_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ais_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'vessels': self.vessels,
            'class_b_vessels': self.class_b_vessels,
            'base_stations': self.base_stations,
            'atons': self.atons,
            'sar_aircraft': self.sar_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _EnvTxAis_message:
    def __init__(self, snr=10, center_frequency='161975000, 162025000', baud=9600, samples_per_symbol=8, BT=0.4, transmitter_start_time=0, count=1, message_type=MessageType2.msg1_position_report, mmsi=338000001, text='ALL CLEAR', lat=37.7749, lon=-122.4194, speed=0.0, course=0.0, heading=511, status=0, rot=-128, name='BUOY', aid_type=1, repeat=0, accuracy=0, to_bow=0, to_stern=0, to_port=0, to_starboard=0, epfd=0, second=60, off_position=0, reserved_1=0, raim=0, virtual_aid=0, assigned=0, name_ext='', shipname='SIGTERA', callsign='KXYZ', ship_type=0, station_type=1, restricted=0, iala_mrn=0, dimension=0, dimensions_a=0, dimensions_b=0, dimension_additional_data=0, charted_status=0, station_status=0, status_bits=0, auth=0, imo=0, month=0, day=0, hour=24, minute=60, draught=5.0, destination='', alt=1000):
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.message_type = message_type
        self.mmsi = mmsi
        self.text = text
        self.lat = lat
        self.lon = lon
        self.speed = speed
        self.course = course
        self.heading = heading
        self.status = status
        self.rot = rot
        self.name = name
        self.aid_type = aid_type
        self.repeat = repeat
        self.accuracy = accuracy
        self.to_bow = to_bow
        self.to_stern = to_stern
        self.to_port = to_port
        self.to_starboard = to_starboard
        self.epfd = epfd
        self.second = second
        self.off_position = off_position
        self.reserved_1 = reserved_1
        self.raim = raim
        self.virtual_aid = virtual_aid
        self.assigned = assigned
        self.name_ext = name_ext
        self.shipname = shipname
        self.callsign = callsign
        self.ship_type = ship_type
        self.station_type = station_type
        self.restricted = restricted
        self.iala_mrn = iala_mrn
        self.dimension = dimension
        self.dimensions_a = dimensions_a
        self.dimensions_b = dimensions_b
        self.dimension_additional_data = dimension_additional_data
        self.charted_status = charted_status
        self.station_status = station_status
        self.status_bits = status_bits
        self.auth = auth
        self.imo = imo
        self.month = month
        self.day = day
        self.hour = hour
        self.minute = minute
        self.draught = draught
        self.destination = destination
        self.alt = alt

    def to_dict(self):
        return {
            'signal': 'ais_message',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'message_type': self.message_type,
            'mmsi': self.mmsi,
            'text': self.text,
            'lat': self.lat,
            'lon': self.lon,
            'speed': self.speed,
            'course': self.course,
            'heading': self.heading,
            'status': self.status,
            'rot': self.rot,
            'name': self.name,
            'aid_type': self.aid_type,
            'repeat': self.repeat,
            'accuracy': self.accuracy,
            'to_bow': self.to_bow,
            'to_stern': self.to_stern,
            'to_port': self.to_port,
            'to_starboard': self.to_starboard,
            'epfd': self.epfd,
            'second': self.second,
            'off_position': self.off_position,
            'reserved_1': self.reserved_1,
            'raim': self.raim,
            'virtual_aid': self.virtual_aid,
            'assigned': self.assigned,
            'name_ext': self.name_ext,
            'shipname': self.shipname,
            'callsign': self.callsign,
            'ship_type': self.ship_type,
            'station_type': self.station_type,
            'restricted': self.restricted,
            'iala_mrn': self.iala_mrn,
            'dimension': self.dimension,
            'dimensions_a': self.dimensions_a,
            'dimensions_b': self.dimensions_b,
            'dimension_additional_data': self.dimension_additional_data,
            'charted_status': self.charted_status,
            'station_status': self.station_status,
            'status_bits': self.status_bits,
            'auth': self.auth,
            'imo': self.imo,
            'month': self.month,
            'day': self.day,
            'hour': self.hour,
            'minute': self.minute,
            'draught': self.draught,
            'destination': self.destination,
            'alt': self.alt,
        }

class _EnvTxAis_transmitter:
    def __init__(self, center_frequency='161975000, 162025000', transmitter_start_time=0, count=1, latitude='37.0-38.0', longitude='-123.0--122.0', slot='0-2249', static_phase='0-360', snr='5-30', length=10, station_type=StationType.class_a, mmsi='992000000-997999999', aton_name='BUOY', aid_type=1, virtual_aid=0, speed='0-25', course='0-360', heading=511, rate_of_turn=0, nav_status=0, ship_name='SIGTERA', callsign='KXYZ', ship_type=70, imo=0, destination='', draught=5.0, to_bow=50, to_stern=20, to_port=5, to_starboard=5, altitude='150-1500'):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.latitude = latitude
        self.longitude = longitude
        self.slot = slot
        self.static_phase = static_phase
        self.snr = snr
        self.length = length
        self.station_type = station_type
        self.mmsi = mmsi
        self.aton_name = aton_name
        self.aid_type = aid_type
        self.virtual_aid = virtual_aid
        self.speed = speed
        self.course = course
        self.heading = heading
        self.rate_of_turn = rate_of_turn
        self.nav_status = nav_status
        self.ship_name = ship_name
        self.callsign = callsign
        self.ship_type = ship_type
        self.imo = imo
        self.destination = destination
        self.draught = draught
        self.to_bow = to_bow
        self.to_stern = to_stern
        self.to_port = to_port
        self.to_starboard = to_starboard
        self.altitude = altitude

    def to_dict(self):
        return {
            'signal': 'ais_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'slot': self.slot,
            'static_phase': self.static_phase,
            'snr': self.snr,
            'length': self.length,
            'station_type': self.station_type,
            'mmsi': self.mmsi,
            'aton_name': self.aton_name,
            'aid_type': self.aid_type,
            'virtual_aid': self.virtual_aid,
            'speed': self.speed,
            'course': self.course,
            'heading': self.heading,
            'rate_of_turn': self.rate_of_turn,
            'nav_status': self.nav_status,
            'ship_name': self.ship_name,
            'callsign': self.callsign,
            'ship_type': self.ship_type,
            'imo': self.imo,
            'destination': self.destination,
            'draught': self.draught,
            'to_bow': self.to_bow,
            'to_stern': self.to_stern,
            'to_port': self.to_port,
            'to_starboard': self.to_starboard,
            'altitude': self.altitude,
        }

class _EnvTxAM:
    def __init__(self, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, transmitter_start_time=0, count=1, duration=0.1, sideband='dsb', modulation_index=0.5, message_bandwidth=3000):
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.duration = duration
        self.sideband = sideband
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'am',
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'duration': self.duration,
            'sideband': self.sideband,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
        }

class _EnvTxAm_group:
    def __init__(self, transmitter_start_time=0, count=1, stations=8, center_frequency='540000:10000:1700000', modulation_index=0.8, message_bandwidth=5000, snr='5-30', length=1):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.stations = stations
        self.center_frequency = center_frequency
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'am_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxAprs:
    def __init__(self, snr=10, center_frequency=0, info_type=InfoType.position, addressee='WB2OSZ', text='Hello', message_no='1', latitude=37.7749, longitude=-122.4194, symbol_table='/', symbol_code='>', course=-1, speed=-1, comment='Sigtera', info='>SIGTERA TEST', transmitter_start_time=0, count=1, source='N0CALL', source_ssid=0, destination='APRS', path='WIDE1-1 WIDE2-2'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.info_type = info_type
        self.addressee = addressee
        self.text = text
        self.message_no = message_no
        self.latitude = latitude
        self.longitude = longitude
        self.symbol_table = symbol_table
        self.symbol_code = symbol_code
        self.course = course
        self.speed = speed
        self.comment = comment
        self.info = info
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.source = source
        self.source_ssid = source_ssid
        self.destination = destination
        self.path = path

    def to_dict(self):
        return {
            'signal': 'aprs',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'info_type': self.info_type,
            'addressee': self.addressee,
            'text': self.text,
            'message_no': self.message_no,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'symbol_table': self.symbol_table,
            'symbol_code': self.symbol_code,
            'course': self.course,
            'speed': self.speed,
            'comment': self.comment,
            'info': self.info,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'source': self.source,
            'source_ssid': self.source_ssid,
            'destination': self.destination,
            'path': self.path,
        }

class _EnvTxAprs_group:
    def __init__(self, transmitter_start_time=0, count=1, mobiles=6, home_stations=1, digipeaters=1, igates=0, center_lat=37.75, center_lon=-122.45, radius=30.0, speed='0-60', beacon_interval='600-1800', snr='5-30', center_frequency='144390000', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.mobiles = mobiles
        self.home_stations = home_stations
        self.digipeaters = digipeaters
        self.igates = igates
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.beacon_interval = beacon_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'aprs_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'mobiles': self.mobiles,
            'home_stations': self.home_stations,
            'digipeaters': self.digipeaters,
            'igates': self.igates,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'beacon_interval': self.beacon_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _EnvTxAprs_transmitter:
    def __init__(self, center_frequency=144390000, transmitter_start_time=0, count=1, source='SIGTRA', source_ssid='0-15', destination='APRS', path='WIDE1-1 WIDE2-2', latitude='37.0-38.0', longitude='-123.0--122.0', comment='Sigtera', status_text='', status_interval=600, first_beacon=0, snr='5-30', length=10, station_kind=StationKind.mobile, beacon_interval='600-1800', speed='0-60', course='0-360', turn_rate=0, fast_rate=90, slow_rate=1800, fast_speed=52, slow_speed=4, turn_angle=28, turn_slope=255, turn_time=15):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.source = source
        self.source_ssid = source_ssid
        self.destination = destination
        self.path = path
        self.latitude = latitude
        self.longitude = longitude
        self.comment = comment
        self.status_text = status_text
        self.status_interval = status_interval
        self.first_beacon = first_beacon
        self.snr = snr
        self.length = length
        self.station_kind = station_kind
        self.beacon_interval = beacon_interval
        self.speed = speed
        self.course = course
        self.turn_rate = turn_rate
        self.fast_rate = fast_rate
        self.slow_rate = slow_rate
        self.fast_speed = fast_speed
        self.slow_speed = slow_speed
        self.turn_angle = turn_angle
        self.turn_slope = turn_slope
        self.turn_time = turn_time

    def to_dict(self):
        return {
            'signal': 'aprs_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'source': self.source,
            'source_ssid': self.source_ssid,
            'destination': self.destination,
            'path': self.path,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'comment': self.comment,
            'status_text': self.status_text,
            'status_interval': self.status_interval,
            'first_beacon': self.first_beacon,
            'snr': self.snr,
            'length': self.length,
            'station_kind': self.station_kind,
            'beacon_interval': self.beacon_interval,
            'speed': self.speed,
            'course': self.course,
            'turn_rate': self.turn_rate,
            'fast_rate': self.fast_rate,
            'slow_rate': self.slow_rate,
            'fast_speed': self.fast_speed,
            'slow_speed': self.slow_speed,
            'turn_angle': self.turn_angle,
            'turn_slope': self.turn_slope,
            'turn_time': self.turn_time,
        }

class _EnvTxApsk:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, modulation_order=16, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'apsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _EnvTxASK:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, modulation_order=2, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ask',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _EnvTxBLE:
    def __init__(self, snr=10, center_frequency=0, baud=1000000, samples_per_symbol=8, BT=0.5, modulation_index=0.5, pdu_type=PduType.adv_ind, target_address='11:22:33:44:55:66', flags=6, device_name='Sigtera', manufacturer_data='', transmitter_start_time=0, count=1, channel=37, advertiser_address='C0:FF:EE:C0:DE:01', address_type=AddressType.public):
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index
        self.pdu_type = pdu_type
        self.target_address = target_address
        self.flags = flags
        self.device_name = device_name
        self.manufacturer_data = manufacturer_data
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.channel = channel
        self.advertiser_address = advertiser_address
        self.address_type = address_type

    def to_dict(self):
        return {
            'signal': 'ble',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
            'pdu_type': self.pdu_type,
            'target_address': self.target_address,
            'flags': self.flags,
            'device_name': self.device_name,
            'manufacturer_data': self.manufacturer_data,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'channel': self.channel,
            'advertiser_address': self.advertiser_address,
            'address_type': self.address_type,
        }

class _EnvTxBle_group:
    def __init__(self, transmitter_start_time=0, count=1, devices=8, beacons=4, directed=0, advertising_interval='0.05-1.0', beacon_uuid='E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', major=1, snr='5-30', center_frequency='2402000000', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.devices = devices
        self.beacons = beacons
        self.directed = directed
        self.advertising_interval = advertising_interval
        self.beacon_uuid = beacon_uuid
        self.major = major
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ble_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'devices': self.devices,
            'beacons': self.beacons,
            'directed': self.directed,
            'advertising_interval': self.advertising_interval,
            'beacon_uuid': self.beacon_uuid,
            'major': self.major,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _EnvTxBle_transmitter:
    def __init__(self, center_frequency=2402000000.0, transmitter_start_time=0, count=1, advertiser_address='C0:FF:EE:C0:DE:01', address_type=AddressType.public, advertising_interval='0.1-1.0', channel_map='37,38,39', first_event=0, snr='5-30', length=10, advertising_type=AdvertisingType.connectable, beacon_uuid='E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', major=1, minor='1-65535', measured_power=-59, device_name='Sigtera', flags=6, manufacturer_data='', scan_probability=0, target_address='11:22:33:44:55:66'):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.advertiser_address = advertiser_address
        self.address_type = address_type
        self.advertising_interval = advertising_interval
        self.channel_map = channel_map
        self.first_event = first_event
        self.snr = snr
        self.length = length
        self.advertising_type = advertising_type
        self.beacon_uuid = beacon_uuid
        self.major = major
        self.minor = minor
        self.measured_power = measured_power
        self.device_name = device_name
        self.flags = flags
        self.manufacturer_data = manufacturer_data
        self.scan_probability = scan_probability
        self.target_address = target_address

    def to_dict(self):
        return {
            'signal': 'ble_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'advertiser_address': self.advertiser_address,
            'address_type': self.address_type,
            'advertising_interval': self.advertising_interval,
            'channel_map': self.channel_map,
            'first_event': self.first_event,
            'snr': self.snr,
            'length': self.length,
            'advertising_type': self.advertising_type,
            'beacon_uuid': self.beacon_uuid,
            'major': self.major,
            'minor': self.minor,
            'measured_power': self.measured_power,
            'device_name': self.device_name,
            'flags': self.flags,
            'manufacturer_data': self.manufacturer_data,
            'scan_probability': self.scan_probability,
            'target_address': self.target_address,
        }

class _EnvTxChirp:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, duration=0.001, bandwidth=10000, waveform=Waveform.linear, code_length='13', num_sweeps=8, direction='up'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.duration = duration
        self.bandwidth = bandwidth
        self.waveform = waveform
        self.code_length = code_length
        self.num_sweeps = num_sweeps
        self.direction = direction

    def to_dict(self):
        return {
            'signal': 'chirp',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'duration': self.duration,
            'bandwidth': self.bandwidth,
            'waveform': self.waveform,
            'code_length': self.code_length,
            'num_sweeps': self.num_sweeps,
            'direction': self.direction,
        }

class _EnvTxCpfsk:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, modulation_order=2, baud=4800, samples_per_symbol=8, modulation_index=0.5):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'cpfsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
        }

class _EnvTxDMR:
    def __init__(self, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1296, transmitter_start_time=0, count=1, content='voice'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.content = content

    def to_dict(self):
        return {
            'signal': 'dmr',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'content': self.content,
        }

class _EnvTxDmr_group:
    def __init__(self, transmitter_start_time=0, count=1, repeaters=4, center_frequency='451000000:12500:452987500', call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.repeaters = repeaters
        self.center_frequency = center_frequency
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'dmr_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'repeaters': self.repeaters,
            'center_frequency': self.center_frequency,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxDmr_transmitter:
    def __init__(self, center_frequency='136000000:12500:173987500, 400000000:12500:469987500', transmitter_start_time=0, count=1, color_code=1, talkgroup='1-65535', active_slots=2, call_duration='2-8', idle='1-10', hang_time=2, first_call=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.color_code = color_code
        self.talkgroup = talkgroup
        self.active_slots = active_slots
        self.call_duration = call_duration
        self.idle = idle
        self.hang_time = hang_time
        self.first_call = first_call
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'dmr_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'color_code': self.color_code,
            'talkgroup': self.talkgroup,
            'active_slots': self.active_slots,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'hang_time': self.hang_time,
            'first_call': self.first_call,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxDpsk:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dpsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
        }

class _EnvTxDqpsk:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, baud=25000):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'dqpsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
        }

class _EnvTxDsss:
    def __init__(self, snr=10, center_frequency=0, samples_per_chip=1, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, sequence=Sequence.barker_13, code='0000011001010', base_modulation=BaseModulation.psk, modulation_order=16, baud=4800, samples_per_symbol=8, modulation_index=0.5, freq_sep=1000, BT=0.5):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_chip = samples_per_chip
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.sequence = sequence
        self.code = code
        self.base_modulation = base_modulation
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.modulation_index = modulation_index
        self.freq_sep = freq_sep
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'dsss',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_chip': self.samples_per_chip,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'sequence': self.sequence,
            'code': self.code,
            'base_modulation': self.base_modulation,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'modulation_index': self.modulation_index,
            'freq_sep': self.freq_sep,
            'BT': self.BT,
        }

class _EnvTxFhss:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, baud=4800, samples_per_symbol=8, freq_sep=2000, num_channels=8, channel_spacing=25000, hop_rate=100, hop_pattern=HopPattern.random, hop_sequence='0 3 1 2'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.num_channels = num_channels
        self.channel_spacing = channel_spacing
        self.hop_rate = hop_rate
        self.hop_pattern = hop_pattern
        self.hop_sequence = hop_sequence

    def to_dict(self):
        return {
            'signal': 'fhss',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'num_channels': self.num_channels,
            'channel_spacing': self.channel_spacing,
            'hop_rate': self.hop_rate,
            'hop_pattern': self.hop_pattern,
            'hop_sequence': self.hop_sequence,
        }

class _EnvTxFM:
    def __init__(self, message=Message.random, frequencies='1000 2500', frequency=1000, snr=10, center_frequency=0, transmitter_start_time=0, count=1, duration=0.1, deviation=5000, message_bandwidth=3000):
        self.message = message
        self.frequencies = frequencies
        self.frequency = frequency
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.duration = duration
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth

    def to_dict(self):
        return {
            'signal': 'fm',
            'message': self.message,
            'frequencies': self.frequencies,
            'frequency': self.frequency,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'duration': self.duration,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
        }

class _EnvTxFm_group:
    def __init__(self, transmitter_start_time=0, count=1, stations=8, center_frequency='88100000:200000:107900000', deviation=75000, message_bandwidth=15000, snr='5-30', length=1):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.stations = stations
        self.center_frequency = center_frequency
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'fm_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxFSK:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1000):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep

    def to_dict(self):
        return {
            'signal': 'fsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
        }

class _EnvTxGfsk:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, baud=4800, samples_per_symbol=8, BT=0.5, modulation_index=0.5):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.modulation_index = modulation_index

    def to_dict(self):
        return {
            'signal': 'gfsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'modulation_index': self.modulation_index,
        }

class _EnvTxGmsk:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, baud=9600, samples_per_symbol=8, BT=0.3):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT

    def to_dict(self):
        return {
            'signal': 'gmsk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
        }

class _EnvTxGPS:
    def __init__(self, snr=10, center_frequency=1575420000, transmitter_start_time=0, count=1, prn='1-32', doppler='-5000-5000', duration=0.02):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.prn = prn
        self.doppler = doppler
        self.duration = duration

    def to_dict(self):
        return {
            'signal': 'gps',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'prn': self.prn,
            'doppler': self.doppler,
            'duration': self.duration,
        }

class _EnvTxGps_group:
    def __init__(self, transmitter_start_time=0, count=1, satellites=8, prn='1:1:32', center_frequency='1575420000', doppler='-5000-5000', snr='5-30', length=0.02):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.satellites = satellites
        self.prn = prn
        self.center_frequency = center_frequency
        self.doppler = doppler
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gps_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'satellites': self.satellites,
            'prn': self.prn,
            'center_frequency': self.center_frequency,
            'doppler': self.doppler,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxGSM:
    def __init__(self, snr=10, center_frequency=0, baud=270833.3333333333, samples_per_symbol=4, BT=0.3, transmitter_start_time=0, count=1, burst_type='normal', tsc=0):
        self.snr = snr
        self.center_frequency = center_frequency
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.BT = BT
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.burst_type = burst_type
        self.tsc = tsc

    def to_dict(self):
        return {
            'signal': 'gsm',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'BT': self.BT,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'burst_type': self.burst_type,
            'tsc': self.tsc,
        }

class _EnvTxGsm_group:
    def __init__(self, transmitter_start_time=0, count=1, cells=6, center_frequency='935200000:200000:959800000', ncc=0, busy_timeslots='0,1,2,3,4,5,6,7', snr='5-30', length=1):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.cells = cells
        self.center_frequency = center_frequency
        self.ncc = ncc
        self.busy_timeslots = busy_timeslots
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gsm_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'cells': self.cells,
            'center_frequency': self.center_frequency,
            'ncc': self.ncc,
            'busy_timeslots': self.busy_timeslots,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxGsm_transmitter:
    def __init__(self, center_frequency='935200000:200000:959800000', transmitter_start_time=0, count=1, ncc=0, bcc='0,1,2,3,4,5,6,7', frame_number='0-2715647', busy_timeslots='0,1,2,3,4,5,6,7', snr='5-30', length=1):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.ncc = ncc
        self.bcc = bcc
        self.frame_number = frame_number
        self.busy_timeslots = busy_timeslots
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gsm_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'ncc': self.ncc,
            'bcc': self.bcc,
            'frame_number': self.frame_number,
            'busy_timeslots': self.busy_timeslots,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxIridium:
    def __init__(self, slot_index=0, snr=10, samples_per_symbol=10, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.4, baud=25000, transmitter_start_time=0, count=1, channel=Channel.simplex, center_frequency=1621000000, duplex_direction=DuplexDirection.downlink, duplex_dl_type=DuplexDlType.vo, da_source=DaSource.text, da_file='', da_chars=10, da_text='SBD MSG', ip_source=DaSource.text, ip_file='', ip_chars=10, ip_text='ip payload', duplex_ul_type=DuplexUlType.aq, rid=42, simplex_type=SimplexType.ms, satellite=42, beam=12, iridium_time=1073741824, ms_source=DaSource.text, ms_file='', ms_chars=10, ms_text='HI', sat_x=1000, sat_y=1200, sat_z=800, tmsi='0x12345678', plane=1, message=1):
        self.slot_index = slot_index
        self.snr = snr
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.baud = baud
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.channel = channel
        self.center_frequency = center_frequency
        self.duplex_direction = duplex_direction
        self.duplex_dl_type = duplex_dl_type
        self.da_source = da_source
        self.da_file = da_file
        self.da_chars = da_chars
        self.da_text = da_text
        self.ip_source = ip_source
        self.ip_file = ip_file
        self.ip_chars = ip_chars
        self.ip_text = ip_text
        self.duplex_ul_type = duplex_ul_type
        self.rid = rid
        self.simplex_type = simplex_type
        self.satellite = satellite
        self.beam = beam
        self.iridium_time = iridium_time
        self.ms_source = ms_source
        self.ms_file = ms_file
        self.ms_chars = ms_chars
        self.ms_text = ms_text
        self.sat_x = sat_x
        self.sat_y = sat_y
        self.sat_z = sat_z
        self.tmsi = tmsi
        self.plane = plane
        self.message = message

    def to_dict(self):
        return {
            'signal': 'iridium',
            'slot_index': self.slot_index,
            'snr': self.snr,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'baud': self.baud,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'channel': self.channel,
            'center_frequency': self.center_frequency,
            'duplex_direction': self.duplex_direction,
            'duplex_dl_type': self.duplex_dl_type,
            'da_source': self.da_source,
            'da_file': self.da_file,
            'da_chars': self.da_chars,
            'da_text': self.da_text,
            'ip_source': self.ip_source,
            'ip_file': self.ip_file,
            'ip_chars': self.ip_chars,
            'ip_text': self.ip_text,
            'duplex_ul_type': self.duplex_ul_type,
            'rid': self.rid,
            'simplex_type': self.simplex_type,
            'satellite': self.satellite,
            'beam': self.beam,
            'iridium_time': self.iridium_time,
            'ms_source': self.ms_source,
            'ms_file': self.ms_file,
            'ms_chars': self.ms_chars,
            'ms_text': self.ms_text,
            'sat_x': self.sat_x,
            'sat_y': self.sat_y,
            'sat_z': self.sat_z,
            'tmsi': self.tmsi,
            'plane': self.plane,
            'message': self.message,
        }

class _EnvTxIridium_group:
    def __init__(self, transmitter_start_time=0, count=1, satellites=6, handsets=2, satellite='1:1:66', center_lat=37.5, center_lon=-122.4, radius=2500.0, beam='1-48', beacon_interval='1-4', broadcast_interval=4.32, iridium_time=1073741824, session_interval='3-8', snr='5-30', center_frequency='1626270833', uplink_frequency='1616020833:41667:1626437500', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.satellites = satellites
        self.handsets = handsets
        self.satellite = satellite
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.beam = beam
        self.beacon_interval = beacon_interval
        self.broadcast_interval = broadcast_interval
        self.iridium_time = iridium_time
        self.session_interval = session_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.uplink_frequency = uplink_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'iridium_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'satellites': self.satellites,
            'handsets': self.handsets,
            'satellite': self.satellite,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'beam': self.beam,
            'beacon_interval': self.beacon_interval,
            'broadcast_interval': self.broadcast_interval,
            'iridium_time': self.iridium_time,
            'session_interval': self.session_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'uplink_frequency': self.uplink_frequency,
            'length': self.length,
        }

class _EnvTxIridium_handset:
    def __init__(self, center_frequency='1616020833:41667:1626437500', transmitter_start_time=0, count=1, tmsi='0x00000001-0xFFFFFFFE', uplink_slot='2,3,4,5', session_interval='3-8', session_offset='0-2', snr='5-30', length=10, activity=Activity.sbd, sbd_text='SBD MSG', call_length='1-3'):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.tmsi = tmsi
        self.uplink_slot = uplink_slot
        self.session_interval = session_interval
        self.session_offset = session_offset
        self.snr = snr
        self.length = length
        self.activity = activity
        self.sbd_text = sbd_text
        self.call_length = call_length

    def to_dict(self):
        return {
            'signal': 'iridium_handset',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'tmsi': self.tmsi,
            'uplink_slot': self.uplink_slot,
            'session_interval': self.session_interval,
            'session_offset': self.session_offset,
            'snr': self.snr,
            'length': self.length,
            'activity': self.activity,
            'sbd_text': self.sbd_text,
            'call_length': self.call_length,
        }

class _EnvTxIridium_satellite:
    def __init__(self, center_frequency=1626270833, transmitter_start_time=0, count=1, satellite='1-66', beam='1-48', plane='1,2,3,4,5,6', orbit_slot='1,2,3,4,5,6,7,8,9,10,11', latitude='-60-60', longitude='-180-180', direction='ascending,descending', altitude=780, inclination=86.4, tmsi='0x12345678', iridium_time=1073741824, beacon_interval=1.0, broadcast_interval=4.32, time_location_interval=0, beacon_offset=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.satellite = satellite
        self.beam = beam
        self.plane = plane
        self.orbit_slot = orbit_slot
        self.latitude = latitude
        self.longitude = longitude
        self.direction = direction
        self.altitude = altitude
        self.inclination = inclination
        self.tmsi = tmsi
        self.iridium_time = iridium_time
        self.beacon_interval = beacon_interval
        self.broadcast_interval = broadcast_interval
        self.time_location_interval = time_location_interval
        self.beacon_offset = beacon_offset
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'iridium_satellite',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'satellite': self.satellite,
            'beam': self.beam,
            'plane': self.plane,
            'orbit_slot': self.orbit_slot,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'direction': self.direction,
            'altitude': self.altitude,
            'inclination': self.inclination,
            'tmsi': self.tmsi,
            'iridium_time': self.iridium_time,
            'beacon_interval': self.beacon_interval,
            'broadcast_interval': self.broadcast_interval,
            'time_location_interval': self.time_location_interval,
            'beacon_offset': self.beacon_offset,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxLora:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2, protocol=Protocol.raw, devaddr='26011BDA', fcnt=1, fport=1, app_payload='48656C6C6F', nwkskey='2B7E151628AED2A6ABF7158809CF4F3C', appskey='2B7E151628AED2A6ABF7158809CF4F3C', route_type=0, payload_type=1, mc_payload='48656C6C6F', dest='FFFFFFFF', sender='336A1B2C', packet_id='12345678', channel_hash=8, portnum=1, text='Hello Mesh', mt_payload=''):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling
        self.protocol = protocol
        self.devaddr = devaddr
        self.fcnt = fcnt
        self.fport = fport
        self.app_payload = app_payload
        self.nwkskey = nwkskey
        self.appskey = appskey
        self.route_type = route_type
        self.payload_type = payload_type
        self.mc_payload = mc_payload
        self.dest = dest
        self.sender = sender
        self.packet_id = packet_id
        self.channel_hash = channel_hash
        self.portnum = portnum
        self.text = text
        self.mt_payload = mt_payload

    def to_dict(self):
        return {
            'signal': 'lora',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
            'protocol': self.protocol,
            'devaddr': self.devaddr,
            'fcnt': self.fcnt,
            'fport': self.fport,
            'app_payload': self.app_payload,
            'nwkskey': self.nwkskey,
            'appskey': self.appskey,
            'route_type': self.route_type,
            'payload_type': self.payload_type,
            'mc_payload': self.mc_payload,
            'dest': self.dest,
            'sender': self.sender,
            'packet_id': self.packet_id,
            'channel_hash': self.channel_hash,
            'portnum': self.portnum,
            'text': self.text,
            'mt_payload': self.mt_payload,
        }

class _EnvTxLorawan:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'lorawan',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _EnvTxLorawan_group:
    def __init__(self, transmitter_start_time=0, count=1, devices=6, tx_interval='5-60', spreading_factor='7,8,9,10', snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.devices = devices
        self.tx_interval = tx_interval
        self.spreading_factor = spreading_factor
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'lorawan_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'devices': self.devices,
            'tx_interval': self.tx_interval,
            'spreading_factor': self.spreading_factor,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxLorawan_transmitter:
    def __init__(self, transmitter_start_time=0, count=1, devaddr='0x26000001-0x27FFFFFE', nwkskey='2B7E151628AED2A6ABF7158809CF4F3C', appskey='2B7E151628AED2A6ABF7158809CF4F3C', fcnt='0-1000', fport=1, app_payload='48656C6C6F', spreading_factor='7,8,9,10', tx_interval='5-60', tx_phase=0, snr='5-30', length=10, region=Region.us915, center_frequency=868100000, sub_band=2):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.devaddr = devaddr
        self.nwkskey = nwkskey
        self.appskey = appskey
        self.fcnt = fcnt
        self.fport = fport
        self.app_payload = app_payload
        self.spreading_factor = spreading_factor
        self.tx_interval = tx_interval
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length
        self.region = region
        self.center_frequency = center_frequency
        self.sub_band = sub_band

    def to_dict(self):
        return {
            'signal': 'lorawan_transmitter',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'devaddr': self.devaddr,
            'nwkskey': self.nwkskey,
            'appskey': self.appskey,
            'fcnt': self.fcnt,
            'fport': self.fport,
            'app_payload': self.app_payload,
            'spreading_factor': self.spreading_factor,
            'tx_interval': self.tx_interval,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
            'region': self.region,
            'center_frequency': self.center_frequency,
            'sub_band': self.sub_band,
        }

class _EnvTxMeshcore:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshcore',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _EnvTxMeshcore_group:
    def __init__(self, transmitter_start_time=0, count=1, devices=6, repeaters=1, center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.devices = devices
        self.repeaters = repeaters
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshcore_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'devices': self.devices,
            'repeaters': self.repeaters,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxMeshcore_transmitter:
    def __init__(self, center_frequency=910525000, transmitter_start_time=0, count=1, node_id='0x00000001-0xFFFFFFFE', node_name='Sigtera', node_type='chat', latitude='37.0-38.0', longitude='-123.0--122.0', advert_interval=3600, timestamp=1790000000, tx_phase=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.node_id = node_id
        self.node_name = node_name
        self.node_type = node_type
        self.latitude = latitude
        self.longitude = longitude
        self.advert_interval = advert_interval
        self.timestamp = timestamp
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshcore_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'node_id': self.node_id,
            'node_name': self.node_name,
            'node_type': self.node_type,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'advert_interval': self.advert_interval,
            'timestamp': self.timestamp,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxMeshtastic:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, spreading_factor=7, bandwidth=125000, coding_rate=1, has_crc='True', implicit_header='False', low_data_rate_optimize='auto', sync_word='0x12', preamble_length=8, oversampling=2):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.spreading_factor = spreading_factor
        self.bandwidth = bandwidth
        self.coding_rate = coding_rate
        self.has_crc = has_crc
        self.implicit_header = implicit_header
        self.low_data_rate_optimize = low_data_rate_optimize
        self.sync_word = sync_word
        self.preamble_length = preamble_length
        self.oversampling = oversampling

    def to_dict(self):
        return {
            'signal': 'meshtastic',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'spreading_factor': self.spreading_factor,
            'bandwidth': self.bandwidth,
            'coding_rate': self.coding_rate,
            'has_crc': self.has_crc,
            'implicit_header': self.implicit_header,
            'low_data_rate_optimize': self.low_data_rate_optimize,
            'sync_word': self.sync_word,
            'preamble_length': self.preamble_length,
            'oversampling': self.oversampling,
        }

class _EnvTxMeshtastic_group:
    def __init__(self, transmitter_start_time=0, count=1, devices=6, modem_preset='long_fast', center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.devices = devices
        self.modem_preset = modem_preset
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshtastic_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'devices': self.devices,
            'modem_preset': self.modem_preset,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxMeshtastic_transmitter:
    def __init__(self, center_frequency=906875000, transmitter_start_time=0, count=1, sender='0x00000001-0xFFFFFFFE', long_name='Sigtera Node', short_name='SIG', modem_preset='long_fast', latitude='37.0-38.0', longitude='-123.0--122.0', altitude='0-500', position_interval=900, nodeinfo_interval=10800, text='', packet_id='0x00000001-0x7FFFFFFF', tx_phase=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.sender = sender
        self.long_name = long_name
        self.short_name = short_name
        self.modem_preset = modem_preset
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.position_interval = position_interval
        self.nodeinfo_interval = nodeinfo_interval
        self.text = text
        self.packet_id = packet_id
        self.tx_phase = tx_phase
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshtastic_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'sender': self.sender,
            'long_name': self.long_name,
            'short_name': self.short_name,
            'modem_preset': self.modem_preset,
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'position_interval': self.position_interval,
            'nodeinfo_interval': self.nodeinfo_interval,
            'text': self.text,
            'packet_id': self.packet_id,
            'tx_phase': self.tx_phase,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxMSK:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, baud=4800, samples_per_symbol=8):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol

    def to_dict(self):
        return {
            'signal': 'msk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
        }

class _EnvTxOfdm:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, modulation_order=2, num_subcarriers=64, fft_size=64, cyclic_prefix_length=16, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.num_subcarriers = num_subcarriers
        self.fft_size = fft_size
        self.cyclic_prefix_length = cyclic_prefix_length
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ofdm',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'num_subcarriers': self.num_subcarriers,
            'fft_size': self.fft_size,
            'cyclic_prefix_length': self.cyclic_prefix_length,
            'baud': self.baud,
        }

class _EnvTxOOK:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'ook',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
        }

class _EnvTxP25:
    def __init__(self, snr=10, center_frequency=0, modulation_order=4, baud=4800, samples_per_symbol=8, freq_sep=1200, transmitter_start_time=0, count=1, duid='voice_ldu1', nac=659):
        self.snr = snr
        self.center_frequency = center_frequency
        self.modulation_order = modulation_order
        self.baud = baud
        self.samples_per_symbol = samples_per_symbol
        self.freq_sep = freq_sep
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.duid = duid
        self.nac = nac

    def to_dict(self):
        return {
            'signal': 'p25',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
            'samples_per_symbol': self.samples_per_symbol,
            'freq_sep': self.freq_sep,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'duid': self.duid,
            'nac': self.nac,
        }

class _EnvTxP25_group:
    def __init__(self, transmitter_start_time=0, count=1, channels=4, center_frequency='769000000:12500:774987500', nac=659, call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.channels = channels
        self.center_frequency = center_frequency
        self.nac = nac
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'p25_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'channels': self.channels,
            'center_frequency': self.center_frequency,
            'nac': self.nac,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxP25_transmitter:
    def __init__(self, center_frequency='769000000:12500:774987500', transmitter_start_time=0, count=1, role='traffic', nac=659, talkgroup='1-65535', call_duration='2-8', idle='1-10', first_call=0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.role = role
        self.nac = nac
        self.talkgroup = talkgroup
        self.call_duration = call_duration
        self.idle = idle
        self.first_call = first_call
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'p25_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'role': self.role,
            'nac': self.nac,
            'talkgroup': self.talkgroup,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'first_call': self.first_call,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxPAM:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, modulation_order=4, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'pam',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _EnvTxPSK:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, modulation_order=4, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'psk',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _EnvTxQAM:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='rectangle', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, modulation_order=16, baud=4800):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.modulation_order = modulation_order
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'qam',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'modulation_order': self.modulation_order,
            'baud': self.baud,
        }

class _EnvTxTetra:
    def __init__(self, snr=10, center_frequency=0, samples_per_symbol=8, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, baud=18000):
        self.snr = snr
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.baud = baud

    def to_dict(self):
        return {
            'signal': 'tetra',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'baud': self.baud,
        }

class _EnvTxTetra_group:
    def __init__(self, transmitter_start_time=0, count=1, carriers=3, center_frequency='390000000:25000:391975000', mcc=901, mnc=1, colour_code='1-63', call_duration='2-8', idle='1-10', snr='5-30', length=1):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.carriers = carriers
        self.center_frequency = center_frequency
        self.mcc = mcc
        self.mnc = mnc
        self.colour_code = colour_code
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'tetra_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'carriers': self.carriers,
            'center_frequency': self.center_frequency,
            'mcc': self.mcc,
            'mnc': self.mnc,
            'colour_code': self.colour_code,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxTetra_transmitter:
    def __init__(self, center_frequency='390000000:25000:399975000', samples_per_symbol=8, pulse_shape='root_raised_cosine', pulse_shape_span=6, pulse_shape_rolloff=0.35, transmitter_start_time=0, count=1, mcc=901, mnc=1, colour_code='1-63', carrier_number='0-4095', carrier_role='main', call_duration='2-8', idle='1-10', baud=18000, snr='5-30', length=1):
        self.center_frequency = center_frequency
        self.samples_per_symbol = samples_per_symbol
        self.pulse_shape = pulse_shape
        self.pulse_shape_span = pulse_shape_span
        self.pulse_shape_rolloff = pulse_shape_rolloff
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.mcc = mcc
        self.mnc = mnc
        self.colour_code = colour_code
        self.carrier_number = carrier_number
        self.carrier_role = carrier_role
        self.call_duration = call_duration
        self.idle = idle
        self.baud = baud
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'tetra_transmitter',
            'center_frequency': self.center_frequency,
            'samples_per_symbol': self.samples_per_symbol,
            'pulse_shape': self.pulse_shape,
            'pulse_shape_span': self.pulse_shape_span,
            'pulse_shape_rolloff': self.pulse_shape_rolloff,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'mcc': self.mcc,
            'mnc': self.mnc,
            'colour_code': self.colour_code,
            'carrier_number': self.carrier_number,
            'carrier_role': self.carrier_role,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'baud': self.baud,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxTone:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, duration=0.1, phase=0):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.duration = duration
        self.phase = phase

    def to_dict(self):
        return {
            'signal': 'tone',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'duration': self.duration,
            'phase': self.phase,
        }

class _EnvTxWifi:
    def __init__(self, snr=10, center_frequency=0, transmitter_start_time=0, count=1, data_rate='36', psdu='0402002E006008CD37A60020D6013CF1006008AD3BAF00004A6F792C2062726967687420', scrambler_init=93):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.data_rate = data_rate
        self.psdu = psdu
        self.scrambler_init = scrambler_init

    def to_dict(self):
        return {
            'signal': 'wifi',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'data_rate': self.data_rate,
            'psdu': self.psdu,
            'scrambler_init': self.scrambler_init,
        }

class _EnvTxWifi_group:
    def __init__(self, transmitter_start_time=0, count=1, access_points=4, center_frequency='5180000000:20000000:5825000000', beacon_interval=0.1024, traffic='0-20', snr='5-30', length=1):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.access_points = access_points
        self.center_frequency = center_frequency
        self.beacon_interval = beacon_interval
        self.traffic = traffic
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'wifi_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'access_points': self.access_points,
            'center_frequency': self.center_frequency,
            'beacon_interval': self.beacon_interval,
            'traffic': self.traffic,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxWifi_transmitter:
    def __init__(self, center_frequency='5180000000:20000000:5825000000', transmitter_start_time=0, count=1, ssid='SIGTERA', bssid='1-16777214', beacon_interval=0.1024, traffic='0-20', uptime='0-86400', sequence_start='0-4095', data_rate='36', snr='5-30', length=1):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.ssid = ssid
        self.bssid = bssid
        self.beacon_interval = beacon_interval
        self.traffic = traffic
        self.uptime = uptime
        self.sequence_start = sequence_start
        self.data_rate = data_rate
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'wifi_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'ssid': self.ssid,
            'bssid': self.bssid,
            'beacon_interval': self.beacon_interval,
            'traffic': self.traffic,
            'uptime': self.uptime,
            'sequence_start': self.sequence_start,
            'data_rate': self.data_rate,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxZigbee:
    def __init__(self, snr=10, center_frequency='2405000000:5000000:2480000000', transmitter_start_time=0, count=1, channel=11, psdu='6188A1FFFF0000010203040506078F62'):
        self.snr = snr
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.channel = channel
        self.psdu = psdu

    def to_dict(self):
        return {
            'signal': 'zigbee',
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'channel': self.channel,
            'psdu': self.psdu,
        }

class _EnvTxZigbee_group:
    def __init__(self, transmitter_start_time=0, count=1, end_devices=5, routers=1, channel=11, pan_id='0x1A62', center_frequency='2405000000', report_interval='0.5-10', snr='5-30', length=10):
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.end_devices = end_devices
        self.routers = routers
        self.channel = channel
        self.pan_id = pan_id
        self.center_frequency = center_frequency
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'zigbee_group',
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'end_devices': self.end_devices,
            'routers': self.routers,
            'channel': self.channel,
            'pan_id': self.pan_id,
            'center_frequency': self.center_frequency,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _EnvTxZigbee_transmitter:
    def __init__(self, center_frequency='2405000000:5000000:2480000000', transmitter_start_time=0, count=1, channel=11, pan_id='0x1A62', short_address='1-65534', parent_address=0, sequence_start='0-255', payload='0102030405060708', report_interval='0.5-10', first_report=0, snr='5-30', length=10, device_role=DeviceRole.end_device, poll_interval=7.5):
        self.center_frequency = center_frequency
        self.transmitter_start_time = transmitter_start_time
        self.count = count
        self.channel = channel
        self.pan_id = pan_id
        self.short_address = short_address
        self.parent_address = parent_address
        self.sequence_start = sequence_start
        self.payload = payload
        self.report_interval = report_interval
        self.first_report = first_report
        self.snr = snr
        self.length = length
        self.device_role = device_role
        self.poll_interval = poll_interval

    def to_dict(self):
        return {
            'signal': 'zigbee_transmitter',
            'center_frequency': self.center_frequency,
            'transmitter_start_time': self.transmitter_start_time,
            'count': self.count,
            'channel': self.channel,
            'pan_id': self.pan_id,
            'short_address': self.short_address,
            'parent_address': self.parent_address,
            'sequence_start': self.sequence_start,
            'payload': self.payload,
            'report_interval': self.report_interval,
            'first_report': self.first_report,
            'snr': self.snr,
            'length': self.length,
            'device_role': self.device_role,
            'poll_interval': self.poll_interval,
        }

class _EnvReceiver:
    def __init__(self, data_type=DataType.iq, format=Format.raw, precision=Precision.float32, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, sample_rate=100000, acquisition_frequency=0):
        self.data_type = data_type
        self.format = format
        self.precision = precision
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.sample_rate = sample_rate
        self.acquisition_frequency = acquisition_frequency

    def to_dict(self):
        return {
            'element': 'receiver',
            'data_type': self.data_type,
            'format': self.format,
            'precision': self.precision,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'sample_rate': self.sample_rate,
            'acquisition_frequency': self.acquisition_frequency,
        }

class _EnvTransmitter:
    def __init__(self):
        self._sig = None

    def Acars(self, **kwargs):
        self._sig = _EnvTxAcars(**kwargs)
        return self._sig

    def Acars_group(self, **kwargs):
        self._sig = _EnvTxAcars_group(**kwargs)
        return self._sig

    def Acars_transmitter(self, **kwargs):
        self._sig = _EnvTxAcars_transmitter(**kwargs)
        return self._sig

    def Adsb(self, **kwargs):
        self._sig = _EnvTxAdsb(**kwargs)
        return self._sig

    def Adsb_group(self, **kwargs):
        self._sig = _EnvTxAdsb_group(**kwargs)
        return self._sig

    def Adsb_transmitter(self, **kwargs):
        self._sig = _EnvTxAdsb_transmitter(**kwargs)
        return self._sig

    def Ais_group(self, **kwargs):
        self._sig = _EnvTxAis_group(**kwargs)
        return self._sig

    def Ais_message(self, **kwargs):
        self._sig = _EnvTxAis_message(**kwargs)
        return self._sig

    def Ais_transmitter(self, **kwargs):
        self._sig = _EnvTxAis_transmitter(**kwargs)
        return self._sig

    def AM(self, **kwargs):
        self._sig = _EnvTxAM(**kwargs)
        return self._sig

    def Am_group(self, **kwargs):
        self._sig = _EnvTxAm_group(**kwargs)
        return self._sig

    def Aprs(self, **kwargs):
        self._sig = _EnvTxAprs(**kwargs)
        return self._sig

    def Aprs_group(self, **kwargs):
        self._sig = _EnvTxAprs_group(**kwargs)
        return self._sig

    def Aprs_transmitter(self, **kwargs):
        self._sig = _EnvTxAprs_transmitter(**kwargs)
        return self._sig

    def Apsk(self, **kwargs):
        self._sig = _EnvTxApsk(**kwargs)
        return self._sig

    def ASK(self, **kwargs):
        self._sig = _EnvTxASK(**kwargs)
        return self._sig

    def BLE(self, **kwargs):
        self._sig = _EnvTxBLE(**kwargs)
        return self._sig

    def Ble_group(self, **kwargs):
        self._sig = _EnvTxBle_group(**kwargs)
        return self._sig

    def Ble_transmitter(self, **kwargs):
        self._sig = _EnvTxBle_transmitter(**kwargs)
        return self._sig

    def Chirp(self, **kwargs):
        self._sig = _EnvTxChirp(**kwargs)
        return self._sig

    def Cpfsk(self, **kwargs):
        self._sig = _EnvTxCpfsk(**kwargs)
        return self._sig

    def DMR(self, **kwargs):
        self._sig = _EnvTxDMR(**kwargs)
        return self._sig

    def Dmr_group(self, **kwargs):
        self._sig = _EnvTxDmr_group(**kwargs)
        return self._sig

    def Dmr_transmitter(self, **kwargs):
        self._sig = _EnvTxDmr_transmitter(**kwargs)
        return self._sig

    def Dpsk(self, **kwargs):
        self._sig = _EnvTxDpsk(**kwargs)
        return self._sig

    def Dqpsk(self, **kwargs):
        self._sig = _EnvTxDqpsk(**kwargs)
        return self._sig

    def Dsss(self, **kwargs):
        self._sig = _EnvTxDsss(**kwargs)
        return self._sig

    def Fhss(self, **kwargs):
        self._sig = _EnvTxFhss(**kwargs)
        return self._sig

    def FM(self, **kwargs):
        self._sig = _EnvTxFM(**kwargs)
        return self._sig

    def Fm_group(self, **kwargs):
        self._sig = _EnvTxFm_group(**kwargs)
        return self._sig

    def FSK(self, **kwargs):
        self._sig = _EnvTxFSK(**kwargs)
        return self._sig

    def Gfsk(self, **kwargs):
        self._sig = _EnvTxGfsk(**kwargs)
        return self._sig

    def Gmsk(self, **kwargs):
        self._sig = _EnvTxGmsk(**kwargs)
        return self._sig

    def GPS(self, **kwargs):
        self._sig = _EnvTxGPS(**kwargs)
        return self._sig

    def Gps_group(self, **kwargs):
        self._sig = _EnvTxGps_group(**kwargs)
        return self._sig

    def GSM(self, **kwargs):
        self._sig = _EnvTxGSM(**kwargs)
        return self._sig

    def Gsm_group(self, **kwargs):
        self._sig = _EnvTxGsm_group(**kwargs)
        return self._sig

    def Gsm_transmitter(self, **kwargs):
        self._sig = _EnvTxGsm_transmitter(**kwargs)
        return self._sig

    def Iridium(self, **kwargs):
        self._sig = _EnvTxIridium(**kwargs)
        return self._sig

    def Iridium_group(self, **kwargs):
        self._sig = _EnvTxIridium_group(**kwargs)
        return self._sig

    def Iridium_handset(self, **kwargs):
        self._sig = _EnvTxIridium_handset(**kwargs)
        return self._sig

    def Iridium_satellite(self, **kwargs):
        self._sig = _EnvTxIridium_satellite(**kwargs)
        return self._sig

    def Lora(self, **kwargs):
        self._sig = _EnvTxLora(**kwargs)
        return self._sig

    def Lorawan(self, **kwargs):
        self._sig = _EnvTxLorawan(**kwargs)
        return self._sig

    def Lorawan_group(self, **kwargs):
        self._sig = _EnvTxLorawan_group(**kwargs)
        return self._sig

    def Lorawan_transmitter(self, **kwargs):
        self._sig = _EnvTxLorawan_transmitter(**kwargs)
        return self._sig

    def Meshcore(self, **kwargs):
        self._sig = _EnvTxMeshcore(**kwargs)
        return self._sig

    def Meshcore_group(self, **kwargs):
        self._sig = _EnvTxMeshcore_group(**kwargs)
        return self._sig

    def Meshcore_transmitter(self, **kwargs):
        self._sig = _EnvTxMeshcore_transmitter(**kwargs)
        return self._sig

    def Meshtastic(self, **kwargs):
        self._sig = _EnvTxMeshtastic(**kwargs)
        return self._sig

    def Meshtastic_group(self, **kwargs):
        self._sig = _EnvTxMeshtastic_group(**kwargs)
        return self._sig

    def Meshtastic_transmitter(self, **kwargs):
        self._sig = _EnvTxMeshtastic_transmitter(**kwargs)
        return self._sig

    def MSK(self, **kwargs):
        self._sig = _EnvTxMSK(**kwargs)
        return self._sig

    def Ofdm(self, **kwargs):
        self._sig = _EnvTxOfdm(**kwargs)
        return self._sig

    def OOK(self, **kwargs):
        self._sig = _EnvTxOOK(**kwargs)
        return self._sig

    def P25(self, **kwargs):
        self._sig = _EnvTxP25(**kwargs)
        return self._sig

    def P25_group(self, **kwargs):
        self._sig = _EnvTxP25_group(**kwargs)
        return self._sig

    def P25_transmitter(self, **kwargs):
        self._sig = _EnvTxP25_transmitter(**kwargs)
        return self._sig

    def PAM(self, **kwargs):
        self._sig = _EnvTxPAM(**kwargs)
        return self._sig

    def PSK(self, **kwargs):
        self._sig = _EnvTxPSK(**kwargs)
        return self._sig

    def QAM(self, **kwargs):
        self._sig = _EnvTxQAM(**kwargs)
        return self._sig

    def Tetra(self, **kwargs):
        self._sig = _EnvTxTetra(**kwargs)
        return self._sig

    def Tetra_group(self, **kwargs):
        self._sig = _EnvTxTetra_group(**kwargs)
        return self._sig

    def Tetra_transmitter(self, **kwargs):
        self._sig = _EnvTxTetra_transmitter(**kwargs)
        return self._sig

    def Tone(self, **kwargs):
        self._sig = _EnvTxTone(**kwargs)
        return self._sig

    def Wifi(self, **kwargs):
        self._sig = _EnvTxWifi(**kwargs)
        return self._sig

    def Wifi_group(self, **kwargs):
        self._sig = _EnvTxWifi_group(**kwargs)
        return self._sig

    def Wifi_transmitter(self, **kwargs):
        self._sig = _EnvTxWifi_transmitter(**kwargs)
        return self._sig

    def Zigbee(self, **kwargs):
        self._sig = _EnvTxZigbee(**kwargs)
        return self._sig

    def Zigbee_group(self, **kwargs):
        self._sig = _EnvTxZigbee_group(**kwargs)
        return self._sig

    def Zigbee_transmitter(self, **kwargs):
        self._sig = _EnvTxZigbee_transmitter(**kwargs)
        return self._sig
    def to_dict(self):
        d = {"element": "transmitter"}
        if self._sig:
            d.update(self._sig.to_dict())
        return d

class _EnvPlatform:
    def __init__(self, latitude=0, longitude=0, altitude=0, velocity_east=0, velocity_north=0, velocity_up=0, self_interference_cancelation='True'):
        self.latitude = latitude
        self.longitude = longitude
        self.altitude = altitude
        self.velocity_east = velocity_east
        self.velocity_north = velocity_north
        self.velocity_up = velocity_up
        self.self_interference_cancelation = self_interference_cancelation
        self._elements = []

    def Receiver(self, **kwargs):
        el = _EnvReceiver(**kwargs)
        self._elements.append(el)
        return el

    def Transmitter(self):
        el = _EnvTransmitter()
        self._elements.append(el)
        return el

    def to_dict(self):
        return {
            'platform': 'platform',
            'latitude': self.latitude,
            'longitude': self.longitude,
            'altitude': self.altitude,
            'velocity_east': self.velocity_east,
            'velocity_north': self.velocity_north,
            'velocity_up': self.velocity_up,
            'self_interference_cancelation': self.self_interference_cancelation,
            'element': [e.to_dict() for e in self._elements],
        }

class _Environment:
    def __init__(self, seed='0-4294967295', length=10, speed_of_propagation=300000000.0, path_loss_exponent=2):
        self.seed = seed
        self.length = length
        self.speed_of_propagation = speed_of_propagation
        self.path_loss_exponent = path_loss_exponent
        self._platforms = []

    def Platform(self, **kwargs):
        plat = _EnvPlatform(**kwargs)
        self._platforms.append(plat)
        return plat

    def to_dict(self):
        return {
            'mode': 'environment_simulation',
            'seed': self.seed,
            'length': self.length,
            'speed_of_propagation': self.speed_of_propagation,
            'path_loss_exponent': self.path_loss_exponent,
            'platform': [p.to_dict() for p in self._platforms],
        }

class _SdrAcars_group:
    def __init__(self, signal_start_time=0, aircraft=6, center_frequency='131550000', center_lat=37.5, center_lon=-122.4, radius=200.0, altitude='1000-40000', ground_speed='150-500', report_interval='10-120', snr='5-30', length=10):
        self.signal_start_time = signal_start_time
        self.aircraft = aircraft
        self.center_frequency = center_frequency
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'acars_group',
            'signal_start_time': self.signal_start_time,
            'aircraft': self.aircraft,
            'center_frequency': self.center_frequency,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrAdsb_group:
    def __init__(self, signal_start_time=0, aircraft=8, ground_aircraft=0, center_lat=37.5, center_lon=-122.4, radius=100.0, altitude='1000-40000', ground_speed='150-500', vertical_rate='-1000-1000', taxi_speed='0-30', snr='5-30', center_frequency='1090000000', length=10):
        self.signal_start_time = signal_start_time
        self.aircraft = aircraft
        self.ground_aircraft = ground_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.altitude = altitude
        self.ground_speed = ground_speed
        self.vertical_rate = vertical_rate
        self.taxi_speed = taxi_speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'adsb_group',
            'signal_start_time': self.signal_start_time,
            'aircraft': self.aircraft,
            'ground_aircraft': self.ground_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'altitude': self.altitude,
            'ground_speed': self.ground_speed,
            'vertical_rate': self.vertical_rate,
            'taxi_speed': self.taxi_speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _SdrAis_group:
    def __init__(self, signal_start_time=0, vessels=8, class_b_vessels=0, base_stations=0, atons=0, sar_aircraft=0, center_lat=37.75, center_lon=-122.45, radius=10.0, speed='0-20', snr='5-30', center_frequency='161975000,162025000', length=10):
        self.signal_start_time = signal_start_time
        self.vessels = vessels
        self.class_b_vessels = class_b_vessels
        self.base_stations = base_stations
        self.atons = atons
        self.sar_aircraft = sar_aircraft
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ais_group',
            'signal_start_time': self.signal_start_time,
            'vessels': self.vessels,
            'class_b_vessels': self.class_b_vessels,
            'base_stations': self.base_stations,
            'atons': self.atons,
            'sar_aircraft': self.sar_aircraft,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _SdrAm_group:
    def __init__(self, signal_start_time=0, stations=8, center_frequency='540000:10000:1700000', modulation_index=0.8, message_bandwidth=5000, snr='5-30', length=1):
        self.signal_start_time = signal_start_time
        self.stations = stations
        self.center_frequency = center_frequency
        self.modulation_index = modulation_index
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'am_group',
            'signal_start_time': self.signal_start_time,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'modulation_index': self.modulation_index,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrAprs_group:
    def __init__(self, signal_start_time=0, mobiles=6, home_stations=1, digipeaters=1, igates=0, center_lat=37.75, center_lon=-122.45, radius=30.0, speed='0-60', beacon_interval='600-1800', snr='5-30', center_frequency='144390000', length=10):
        self.signal_start_time = signal_start_time
        self.mobiles = mobiles
        self.home_stations = home_stations
        self.digipeaters = digipeaters
        self.igates = igates
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.speed = speed
        self.beacon_interval = beacon_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'aprs_group',
            'signal_start_time': self.signal_start_time,
            'mobiles': self.mobiles,
            'home_stations': self.home_stations,
            'digipeaters': self.digipeaters,
            'igates': self.igates,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'speed': self.speed,
            'beacon_interval': self.beacon_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _SdrBle_group:
    def __init__(self, signal_start_time=0, devices=8, beacons=4, directed=0, advertising_interval='0.05-1.0', beacon_uuid='E2C56DB5-DFFB-48D2-B060-D0F5A71096E0', major=1, snr='5-30', center_frequency='2402000000', length=10):
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.beacons = beacons
        self.directed = directed
        self.advertising_interval = advertising_interval
        self.beacon_uuid = beacon_uuid
        self.major = major
        self.snr = snr
        self.center_frequency = center_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'ble_group',
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'beacons': self.beacons,
            'directed': self.directed,
            'advertising_interval': self.advertising_interval,
            'beacon_uuid': self.beacon_uuid,
            'major': self.major,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'length': self.length,
        }

class _SdrDmr_group:
    def __init__(self, signal_start_time=0, repeaters=4, center_frequency='451000000:12500:452987500', call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.signal_start_time = signal_start_time
        self.repeaters = repeaters
        self.center_frequency = center_frequency
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'dmr_group',
            'signal_start_time': self.signal_start_time,
            'repeaters': self.repeaters,
            'center_frequency': self.center_frequency,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrFm_group:
    def __init__(self, signal_start_time=0, stations=8, center_frequency='88100000:200000:107900000', deviation=75000, message_bandwidth=15000, snr='5-30', length=1):
        self.signal_start_time = signal_start_time
        self.stations = stations
        self.center_frequency = center_frequency
        self.deviation = deviation
        self.message_bandwidth = message_bandwidth
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'fm_group',
            'signal_start_time': self.signal_start_time,
            'stations': self.stations,
            'center_frequency': self.center_frequency,
            'deviation': self.deviation,
            'message_bandwidth': self.message_bandwidth,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrGps_group:
    def __init__(self, signal_start_time=0, satellites=8, prn='1:1:32', center_frequency='1575420000', doppler='-5000-5000', snr='5-30', length=0.02):
        self.signal_start_time = signal_start_time
        self.satellites = satellites
        self.prn = prn
        self.center_frequency = center_frequency
        self.doppler = doppler
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gps_group',
            'signal_start_time': self.signal_start_time,
            'satellites': self.satellites,
            'prn': self.prn,
            'center_frequency': self.center_frequency,
            'doppler': self.doppler,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrGsm_group:
    def __init__(self, signal_start_time=0, cells=6, center_frequency='935200000:200000:959800000', ncc=0, busy_timeslots='0,1,2,3,4,5,6,7', snr='5-30', length=1):
        self.signal_start_time = signal_start_time
        self.cells = cells
        self.center_frequency = center_frequency
        self.ncc = ncc
        self.busy_timeslots = busy_timeslots
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'gsm_group',
            'signal_start_time': self.signal_start_time,
            'cells': self.cells,
            'center_frequency': self.center_frequency,
            'ncc': self.ncc,
            'busy_timeslots': self.busy_timeslots,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrIridium_group:
    def __init__(self, signal_start_time=0, satellites=6, handsets=2, satellite='1:1:66', center_lat=37.5, center_lon=-122.4, radius=2500.0, beam='1-48', beacon_interval='1-4', broadcast_interval=4.32, iridium_time=1073741824, session_interval='3-8', snr='5-30', center_frequency='1626270833', uplink_frequency='1616020833:41667:1626437500', length=10):
        self.signal_start_time = signal_start_time
        self.satellites = satellites
        self.handsets = handsets
        self.satellite = satellite
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.beam = beam
        self.beacon_interval = beacon_interval
        self.broadcast_interval = broadcast_interval
        self.iridium_time = iridium_time
        self.session_interval = session_interval
        self.snr = snr
        self.center_frequency = center_frequency
        self.uplink_frequency = uplink_frequency
        self.length = length

    def to_dict(self):
        return {
            'signal': 'iridium_group',
            'signal_start_time': self.signal_start_time,
            'satellites': self.satellites,
            'handsets': self.handsets,
            'satellite': self.satellite,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'beam': self.beam,
            'beacon_interval': self.beacon_interval,
            'broadcast_interval': self.broadcast_interval,
            'iridium_time': self.iridium_time,
            'session_interval': self.session_interval,
            'snr': self.snr,
            'center_frequency': self.center_frequency,
            'uplink_frequency': self.uplink_frequency,
            'length': self.length,
        }

class _SdrLorawan_group:
    def __init__(self, center_frequency='902300000:200000:914900000', signal_start_time=0, devices=6, tx_interval='5-60', spreading_factor='7,8,9,10', snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.tx_interval = tx_interval
        self.spreading_factor = spreading_factor
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'lorawan_group',
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'tx_interval': self.tx_interval,
            'spreading_factor': self.spreading_factor,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrMeshcore_group:
    def __init__(self, center_frequency=910525000, signal_start_time=0, devices=6, repeaters=1, center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.repeaters = repeaters
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshcore_group',
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'repeaters': self.repeaters,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrMeshtastic_group:
    def __init__(self, center_frequency='902000000:250000:927750000', signal_start_time=0, devices=6, modem_preset='long_fast', center_lat=37.5, center_lon=-122.4, radius=20.0, snr='5-30', length=10):
        self.center_frequency = center_frequency
        self.signal_start_time = signal_start_time
        self.devices = devices
        self.modem_preset = modem_preset
        self.center_lat = center_lat
        self.center_lon = center_lon
        self.radius = radius
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'meshtastic_group',
            'center_frequency': self.center_frequency,
            'signal_start_time': self.signal_start_time,
            'devices': self.devices,
            'modem_preset': self.modem_preset,
            'center_lat': self.center_lat,
            'center_lon': self.center_lon,
            'radius': self.radius,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrP25_group:
    def __init__(self, signal_start_time=0, channels=4, center_frequency='769000000:12500:774987500', nac=659, call_duration='2-8', idle='1-10', snr='5-30', length=10):
        self.signal_start_time = signal_start_time
        self.channels = channels
        self.center_frequency = center_frequency
        self.nac = nac
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'p25_group',
            'signal_start_time': self.signal_start_time,
            'channels': self.channels,
            'center_frequency': self.center_frequency,
            'nac': self.nac,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrTetra_group:
    def __init__(self, signal_start_time=0, carriers=3, center_frequency='390000000:25000:391975000', mcc=901, mnc=1, colour_code='1-63', call_duration='2-8', idle='1-10', snr='5-30', length=1):
        self.signal_start_time = signal_start_time
        self.carriers = carriers
        self.center_frequency = center_frequency
        self.mcc = mcc
        self.mnc = mnc
        self.colour_code = colour_code
        self.call_duration = call_duration
        self.idle = idle
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'tetra_group',
            'signal_start_time': self.signal_start_time,
            'carriers': self.carriers,
            'center_frequency': self.center_frequency,
            'mcc': self.mcc,
            'mnc': self.mnc,
            'colour_code': self.colour_code,
            'call_duration': self.call_duration,
            'idle': self.idle,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrWifi_group:
    def __init__(self, signal_start_time=0, access_points=4, center_frequency='5180000000:20000000:5825000000', beacon_interval=0.1024, traffic='0-20', snr='5-30', length=1):
        self.signal_start_time = signal_start_time
        self.access_points = access_points
        self.center_frequency = center_frequency
        self.beacon_interval = beacon_interval
        self.traffic = traffic
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'wifi_group',
            'signal_start_time': self.signal_start_time,
            'access_points': self.access_points,
            'center_frequency': self.center_frequency,
            'beacon_interval': self.beacon_interval,
            'traffic': self.traffic,
            'snr': self.snr,
            'length': self.length,
        }

class _SdrZigbee_group:
    def __init__(self, signal_start_time=0, end_devices=5, routers=1, channel=11, pan_id='0x1A62', center_frequency='2405000000', report_interval='0.5-10', snr='5-30', length=10):
        self.signal_start_time = signal_start_time
        self.end_devices = end_devices
        self.routers = routers
        self.channel = channel
        self.pan_id = pan_id
        self.center_frequency = center_frequency
        self.report_interval = report_interval
        self.snr = snr
        self.length = length

    def to_dict(self):
        return {
            'signal': 'zigbee_group',
            'signal_start_time': self.signal_start_time,
            'end_devices': self.end_devices,
            'routers': self.routers,
            'channel': self.channel,
            'pan_id': self.pan_id,
            'center_frequency': self.center_frequency,
            'report_interval': self.report_interval,
            'snr': self.snr,
            'length': self.length,
        }

class _VirtualSDR:
    def __init__(self, seed='0-4294967295', data_type=DataType.iq, format=Format.raw, precision=Precision.float32, front_end=FrontEnd.front_end, clock_offset=0, dc_offset_i=0, dc_offset_q=0, iq_gain_imbalance=0, iq_phase_imbalance=0, phase_noise=0, cfo=0, noise=-10, acquisition_frequency=162000000, length=1, sample_rate=2000000):
        self.seed = seed
        self.data_type = data_type
        self.format = format
        self.precision = precision
        self.front_end = front_end
        self.clock_offset = clock_offset
        self.dc_offset_i = dc_offset_i
        self.dc_offset_q = dc_offset_q
        self.iq_gain_imbalance = iq_gain_imbalance
        self.iq_phase_imbalance = iq_phase_imbalance
        self.phase_noise = phase_noise
        self.cfo = cfo
        self.noise = noise
        self.acquisition_frequency = acquisition_frequency
        self.length = length
        self.sample_rate = sample_rate
        self._signals = []

    def Acars_group(self, **kwargs):
        sig = _SdrAcars_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Adsb_group(self, **kwargs):
        sig = _SdrAdsb_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Ais_group(self, **kwargs):
        sig = _SdrAis_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Am_group(self, **kwargs):
        sig = _SdrAm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Aprs_group(self, **kwargs):
        sig = _SdrAprs_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Ble_group(self, **kwargs):
        sig = _SdrBle_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Dmr_group(self, **kwargs):
        sig = _SdrDmr_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Fm_group(self, **kwargs):
        sig = _SdrFm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Gps_group(self, **kwargs):
        sig = _SdrGps_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Gsm_group(self, **kwargs):
        sig = _SdrGsm_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Iridium_group(self, **kwargs):
        sig = _SdrIridium_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Lorawan_group(self, **kwargs):
        sig = _SdrLorawan_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshcore_group(self, **kwargs):
        sig = _SdrMeshcore_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Meshtastic_group(self, **kwargs):
        sig = _SdrMeshtastic_group(**kwargs)
        self._signals.append(sig)
        return sig

    def P25_group(self, **kwargs):
        sig = _SdrP25_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Tetra_group(self, **kwargs):
        sig = _SdrTetra_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Wifi_group(self, **kwargs):
        sig = _SdrWifi_group(**kwargs)
        self._signals.append(sig)
        return sig

    def Zigbee_group(self, **kwargs):
        sig = _SdrZigbee_group(**kwargs)
        self._signals.append(sig)
        return sig
    def to_dict(self):
        return {
            'mode': 'virtual_sdr',
            'seed': self.seed,
            'data_type': self.data_type,
            'format': self.format,
            'precision': self.precision,
            'front_end': self.front_end,
            'clock_offset': self.clock_offset,
            'dc_offset_i': self.dc_offset_i,
            'dc_offset_q': self.dc_offset_q,
            'iq_gain_imbalance': self.iq_gain_imbalance,
            'iq_phase_imbalance': self.iq_phase_imbalance,
            'phase_noise': self.phase_noise,
            'cfo': self.cfo,
            'noise': self.noise,
            'acquisition_frequency': self.acquisition_frequency,
            'length': self.length,
            'sample_rate': self.sample_rate,
            'signal': [s.to_dict() for s in self._signals],
        }

class SigteraClient:
    def __init__(self, url='https://api.sigtera.com', api_key=None):
        self.url = url
        # Sent as `Authorization: Bearer <key>` to attribute requests to your account. Falls back to
        # the SIGTERA_API_KEY environment variable. Anonymous (no key) requests still work.
        self.api_key = api_key or os.environ.get('SIGTERA_API_KEY')
        self._requests = []

    def narrowband(self, **kwargs):
        req = _BasebandCuts(**kwargs)
        self._requests.append(req)
        return req

    def wideband(self, **kwargs):
        req = _Wideband(**kwargs)
        self._requests.append(req)
        return req

    def environment(self, **kwargs):
        req = _Environment(**kwargs)
        self._requests.append(req)
        return req

    def virtual_sdr(self, **kwargs):
        req = _VirtualSDR(**kwargs)
        self._requests.append(req)
        return req

    def simulate(self):
        for req in self._requests:
            yield from self._send(req)

    def _send(self, req):
        headers = {'Authorization': f'Bearer {self.api_key}'} if self.api_key else {}
        with requests.post(f'{self.url}/api', json=req.to_dict(), stream=True, headers=headers) as r:
            r.raise_for_status()
            yield from self._parse(r)

    def _parse(self, r):
        buf = bytearray()
        it = r.iter_content(chunk_size=65536)

        def fill(n):
            while len(buf) < n:
                try:
                    buf.extend(next(it))
                except StopIteration:
                    return

        def read_frame():
            fill(4)
            if len(buf) < 4:
                return None, b''
            n = int.from_bytes(buf[:4], 'big')
            if n == 0:
                del buf[:4]
                return 0, b''
            fill(4 + n)
            data = bytes(buf[4:4 + n])
            del buf[:4 + n]
            return n, data

        while True:
            n, data = read_frame()
            if n is None:
                return
            sig_params = json.loads(data)
            chunks = []
            while True:
                n, data = read_frame()
                if n == 0 or n is None:
                    break
                chunks.append(data)
            yield sig_params, b''.join(chunks)