1613 lines
72 KiB
Ruby
1613 lines
72 KiB
Ruby
# Copyright 2015 Google Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
require 'date'
|
|
require 'google/apis/core/base_service'
|
|
require 'google/apis/core/json_representation'
|
|
require 'google/apis/core/hashable'
|
|
require 'google/apis/errors'
|
|
|
|
module Google
|
|
module Apis
|
|
module SpectrumV1explorer
|
|
|
|
# Antenna characteristics provide additional information, such as the antenna
|
|
# height, antenna type, etc. Whether antenna characteristics must be provided in
|
|
# a request depends on the device type and regulatory domain.
|
|
class AntennaCharacteristics
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The antenna height in meters. Whether the antenna height is required depends
|
|
# on the device type and the regulatory domain. Note that the height may be
|
|
# negative.
|
|
# Corresponds to the JSON property `height`
|
|
# @return [Float]
|
|
attr_accessor :height
|
|
|
|
# If the height is required, then the height type (AGL for above ground level or
|
|
# AMSL for above mean sea level) is also required. The default is AGL.
|
|
# Corresponds to the JSON property `heightType`
|
|
# @return [String]
|
|
attr_accessor :height_type
|
|
|
|
# The height uncertainty in meters. Whether this is required depends on the
|
|
# regulatory domain.
|
|
# Corresponds to the JSON property `heightUncertainty`
|
|
# @return [Float]
|
|
attr_accessor :height_uncertainty
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@height = args[:height] if args.key?(:height)
|
|
@height_type = args[:height_type] if args.key?(:height_type)
|
|
@height_uncertainty = args[:height_uncertainty] if args.key?(:height_uncertainty)
|
|
end
|
|
end
|
|
|
|
# This message contains the name and URI of a database.
|
|
class DatabaseSpec
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The display name for a database.
|
|
# Corresponds to the JSON property `name`
|
|
# @return [String]
|
|
attr_accessor :name
|
|
|
|
# The corresponding URI of the database.
|
|
# Corresponds to the JSON property `uri`
|
|
# @return [String]
|
|
attr_accessor :uri
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@name = args[:name] if args.key?(:name)
|
|
@uri = args[:uri] if args.key?(:uri)
|
|
end
|
|
end
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
class DbUpdateSpec
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A required list of one or more databases. A device should update its
|
|
# preconfigured list of databases to replace (only) the database that provided
|
|
# the response with the specified entries.
|
|
# Corresponds to the JSON property `databases`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::DatabaseSpec>]
|
|
attr_accessor :databases
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@databases = args[:databases] if args.key?(:databases)
|
|
end
|
|
end
|
|
|
|
# Device capabilities provide additional information that may be used by a
|
|
# device to provide additional information to the database that may help it to
|
|
# determine available spectrum. If the database does not support device
|
|
# capabilities it will ignore the parameter altogether.
|
|
class DeviceCapabilities
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# An optional list of frequency ranges supported by the device. Each element
|
|
# must contain start and stop frequencies in which the device can operate.
|
|
# Channel identifiers are optional. When specified, the database should not
|
|
# return available spectrum that falls outside these ranges or channel IDs.
|
|
# Corresponds to the JSON property `frequencyRanges`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::FrequencyRange>]
|
|
attr_accessor :frequency_ranges
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@frequency_ranges = args[:frequency_ranges] if args.key?(:frequency_ranges)
|
|
end
|
|
end
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
class DeviceDescriptor
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Specifies the ETSI white space device category. Valid values are the strings
|
|
# master and slave. This field is case-insensitive. Consult the ETSI
|
|
# documentation for details about the device types.
|
|
# Corresponds to the JSON property `etsiEnDeviceCategory`
|
|
# @return [String]
|
|
attr_accessor :etsi_en_device_category
|
|
|
|
# Specifies the ETSI white space device emissions class. The values are
|
|
# represented by numeric strings, such as 1, 2, etc. Consult the ETSI
|
|
# documentation for details about the device types.
|
|
# Corresponds to the JSON property `etsiEnDeviceEmissionsClass`
|
|
# @return [String]
|
|
attr_accessor :etsi_en_device_emissions_class
|
|
|
|
# Specifies the ETSI white space device type. Valid values are single-letter
|
|
# strings, such as A, B, etc. Consult the ETSI documentation for details about
|
|
# the device types.
|
|
# Corresponds to the JSON property `etsiEnDeviceType`
|
|
# @return [String]
|
|
attr_accessor :etsi_en_device_type
|
|
|
|
# Specifies the ETSI white space device technology identifier. The string value
|
|
# must not exceed 64 characters in length. Consult the ETSI documentation for
|
|
# details about the device types.
|
|
# Corresponds to the JSON property `etsiEnTechnologyId`
|
|
# @return [String]
|
|
attr_accessor :etsi_en_technology_id
|
|
|
|
# Specifies the device's FCC certification identifier. The value is an
|
|
# identifier string whose length should not exceed 32 characters. Note that, in
|
|
# practice, a valid FCC ID may be limited to 19 characters.
|
|
# Corresponds to the JSON property `fccId`
|
|
# @return [String]
|
|
attr_accessor :fcc_id
|
|
|
|
# Specifies the TV Band White Space device type, as defined by the FCC. Valid
|
|
# values are FIXED, MODE_1, MODE_2.
|
|
# Corresponds to the JSON property `fccTvbdDeviceType`
|
|
# @return [String]
|
|
attr_accessor :fcc_tvbd_device_type
|
|
|
|
# The manufacturer's ID may be required by the regulatory domain. This should
|
|
# represent the name of the device manufacturer, should be consistent across all
|
|
# devices from the same manufacturer, and should be distinct from that of other
|
|
# manufacturers. The string value must not exceed 64 characters in length.
|
|
# Corresponds to the JSON property `manufacturerId`
|
|
# @return [String]
|
|
attr_accessor :manufacturer_id
|
|
|
|
# The device's model ID may be required by the regulatory domain. The string
|
|
# value must not exceed 64 characters in length.
|
|
# Corresponds to the JSON property `modelId`
|
|
# @return [String]
|
|
attr_accessor :model_id
|
|
|
|
# The list of identifiers for rulesets supported by the device. A database may
|
|
# require that the device provide this list before servicing the device requests.
|
|
# If the database does not support any of the rulesets specified in the list,
|
|
# the database may refuse to service the device requests. If present, the list
|
|
# must contain at least one entry.
|
|
# For information about the valid requests, see section 9.2 of the PAWS
|
|
# specification. Currently, FccTvBandWhiteSpace-2010 is the only supported
|
|
# ruleset.
|
|
# Corresponds to the JSON property `rulesetIds`
|
|
# @return [Array<String>]
|
|
attr_accessor :ruleset_ids
|
|
|
|
# The manufacturer's device serial number; required by the applicable regulatory
|
|
# domain. The length of the value must not exceed 64 characters.
|
|
# Corresponds to the JSON property `serialNumber`
|
|
# @return [String]
|
|
attr_accessor :serial_number
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@etsi_en_device_category = args[:etsi_en_device_category] if args.key?(:etsi_en_device_category)
|
|
@etsi_en_device_emissions_class = args[:etsi_en_device_emissions_class] if args.key?(:etsi_en_device_emissions_class)
|
|
@etsi_en_device_type = args[:etsi_en_device_type] if args.key?(:etsi_en_device_type)
|
|
@etsi_en_technology_id = args[:etsi_en_technology_id] if args.key?(:etsi_en_technology_id)
|
|
@fcc_id = args[:fcc_id] if args.key?(:fcc_id)
|
|
@fcc_tvbd_device_type = args[:fcc_tvbd_device_type] if args.key?(:fcc_tvbd_device_type)
|
|
@manufacturer_id = args[:manufacturer_id] if args.key?(:manufacturer_id)
|
|
@model_id = args[:model_id] if args.key?(:model_id)
|
|
@ruleset_ids = args[:ruleset_ids] if args.key?(:ruleset_ids)
|
|
@serial_number = args[:serial_number] if args.key?(:serial_number)
|
|
end
|
|
end
|
|
|
|
# This parameter contains device-owner information required as part of device
|
|
# registration. The regulatory domains may require additional parameters.
|
|
# All contact information must be expressed using the structure defined by the
|
|
# vCard format specification. Only the contact fields of vCard are supported:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Note that the vCard specification defines maximum lengths for each field.
|
|
class DeviceOwner
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A vCard-in-JSON message that contains only the fields needed for PAWS:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Corresponds to the JSON property `operator`
|
|
# @return [Google::Apis::SpectrumV1explorer::Vcard]
|
|
attr_accessor :operator
|
|
|
|
# A vCard-in-JSON message that contains only the fields needed for PAWS:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Corresponds to the JSON property `owner`
|
|
# @return [Google::Apis::SpectrumV1explorer::Vcard]
|
|
attr_accessor :owner
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@operator = args[:operator] if args.key?(:operator)
|
|
@owner = args[:owner] if args.key?(:owner)
|
|
end
|
|
end
|
|
|
|
# The device validity element describes whether a particular device is valid to
|
|
# operate in the regulatory domain.
|
|
class DeviceValidity
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# The validity status: true if the device is valid for operation, false
|
|
# otherwise. It will always be present.
|
|
# Corresponds to the JSON property `isValid`
|
|
# @return [Boolean]
|
|
attr_accessor :is_valid
|
|
alias_method :is_valid?, :is_valid
|
|
|
|
# If the device identifier is not valid, the database may include a reason. The
|
|
# reason may be in any language. The length of the value should not exceed 128
|
|
# characters.
|
|
# Corresponds to the JSON property `reason`
|
|
# @return [String]
|
|
attr_accessor :reason
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@is_valid = args[:is_valid] if args.key?(:is_valid)
|
|
@reason = args[:reason] if args.key?(:reason)
|
|
end
|
|
end
|
|
|
|
# The start and stop times of an event. This is used to indicate the time period
|
|
# for which a spectrum profile is valid.
|
|
# Both times are expressed using the format, YYYY-MM-DDThh:mm:ssZ, as defined in
|
|
# RFC3339. The times must be expressed using UTC.
|
|
class EventTime
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The inclusive start of the event. It will be present.
|
|
# Corresponds to the JSON property `startTime`
|
|
# @return [String]
|
|
attr_accessor :start_time
|
|
|
|
# The exclusive end of the event. It will be present.
|
|
# Corresponds to the JSON property `stopTime`
|
|
# @return [String]
|
|
attr_accessor :stop_time
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@start_time = args[:start_time] if args.key?(:start_time)
|
|
@stop_time = args[:stop_time] if args.key?(:stop_time)
|
|
end
|
|
end
|
|
|
|
# A specific range of frequencies together with the associated maximum power
|
|
# level and channel identifier.
|
|
class FrequencyRange
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The database may include a channel identifier, when applicable. When it is
|
|
# included, the device should treat it as informative. The length of the
|
|
# identifier should not exceed 16 characters.
|
|
# Corresponds to the JSON property `channelId`
|
|
# @return [String]
|
|
attr_accessor :channel_id
|
|
|
|
# The maximum total power level (EIRP)—computed over the corresponding operating
|
|
# bandwidth—that is permitted within the frequency range. Depending on the
|
|
# context in which the frequency-range element appears, this value may be
|
|
# required. For example, it is required in the available-spectrum response,
|
|
# available-spectrum-batch response, and spectrum-use notification message, but
|
|
# it should not be present (it is not applicable) when the frequency range
|
|
# appears inside a device-capabilities message.
|
|
# Corresponds to the JSON property `maxPowerDBm`
|
|
# @return [Float]
|
|
attr_accessor :max_power_d_bm
|
|
|
|
# The required inclusive start of the frequency range (in Hertz).
|
|
# Corresponds to the JSON property `startHz`
|
|
# @return [Float]
|
|
attr_accessor :start_hz
|
|
|
|
# The required exclusive end of the frequency range (in Hertz).
|
|
# Corresponds to the JSON property `stopHz`
|
|
# @return [Float]
|
|
attr_accessor :stop_hz
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@channel_id = args[:channel_id] if args.key?(:channel_id)
|
|
@max_power_d_bm = args[:max_power_d_bm] if args.key?(:max_power_d_bm)
|
|
@start_hz = args[:start_hz] if args.key?(:start_hz)
|
|
@stop_hz = args[:stop_hz] if args.key?(:stop_hz)
|
|
end
|
|
end
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
class GeoLocation
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The location confidence level, as an integer percentage, may be required,
|
|
# depending on the regulatory domain. When the parameter is optional and not
|
|
# provided, its value is assumed to be 95. Valid values range from 0 to 99,
|
|
# since, in practice, 100-percent confidence is not achievable. The confidence
|
|
# value is meaningful only when geolocation refers to a point with uncertainty.
|
|
# Corresponds to the JSON property `confidence`
|
|
# @return [Fixnum]
|
|
attr_accessor :confidence
|
|
|
|
# A "point" with uncertainty is represented using the Ellipse shape.
|
|
# Corresponds to the JSON property `point`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocationEllipse]
|
|
attr_accessor :point
|
|
|
|
# A region is represented using the polygonal shape.
|
|
# Corresponds to the JSON property `region`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocationPolygon]
|
|
attr_accessor :region
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@confidence = args[:confidence] if args.key?(:confidence)
|
|
@point = args[:point] if args.key?(:point)
|
|
@region = args[:region] if args.key?(:region)
|
|
end
|
|
end
|
|
|
|
# A "point" with uncertainty is represented using the Ellipse shape.
|
|
class GeoLocationEllipse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A single geolocation on the globe.
|
|
# Corresponds to the JSON property `center`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocationPoint]
|
|
attr_accessor :center
|
|
|
|
# A floating-point number that expresses the orientation of the ellipse,
|
|
# representing the rotation, in degrees, of the semi-major axis from North
|
|
# towards the East. For example, when the uncertainty is greatest along the
|
|
# North-South direction, orientation is 0 degrees; conversely, if the
|
|
# uncertainty is greatest along the East-West direction, orientation is 90
|
|
# degrees. When orientation is not present, the orientation is assumed to be 0.
|
|
# Corresponds to the JSON property `orientation`
|
|
# @return [Float]
|
|
attr_accessor :orientation
|
|
|
|
# A floating-point number that expresses the location uncertainty along the
|
|
# major axis of the ellipse. May be required by the regulatory domain. When the
|
|
# uncertainty is optional, the default value is 0.
|
|
# Corresponds to the JSON property `semiMajorAxis`
|
|
# @return [Float]
|
|
attr_accessor :semi_major_axis
|
|
|
|
# A floating-point number that expresses the location uncertainty along the
|
|
# minor axis of the ellipse. May be required by the regulatory domain. When the
|
|
# uncertainty is optional, the default value is 0.
|
|
# Corresponds to the JSON property `semiMinorAxis`
|
|
# @return [Float]
|
|
attr_accessor :semi_minor_axis
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@center = args[:center] if args.key?(:center)
|
|
@orientation = args[:orientation] if args.key?(:orientation)
|
|
@semi_major_axis = args[:semi_major_axis] if args.key?(:semi_major_axis)
|
|
@semi_minor_axis = args[:semi_minor_axis] if args.key?(:semi_minor_axis)
|
|
end
|
|
end
|
|
|
|
# A single geolocation on the globe.
|
|
class GeoLocationPoint
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A required floating-point number that expresses the latitude in degrees using
|
|
# the WGS84 datum. For details on this encoding, see the National Imagery and
|
|
# Mapping Agency's Technical Report TR8350.2.
|
|
# Corresponds to the JSON property `latitude`
|
|
# @return [Float]
|
|
attr_accessor :latitude
|
|
|
|
# A required floating-point number that expresses the longitude in degrees using
|
|
# the WGS84 datum. For details on this encoding, see the National Imagery and
|
|
# Mapping Agency's Technical Report TR8350.2.
|
|
# Corresponds to the JSON property `longitude`
|
|
# @return [Float]
|
|
attr_accessor :longitude
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@latitude = args[:latitude] if args.key?(:latitude)
|
|
@longitude = args[:longitude] if args.key?(:longitude)
|
|
end
|
|
end
|
|
|
|
# A region is represented using the polygonal shape.
|
|
class GeoLocationPolygon
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# When the geolocation describes a region, the exterior field refers to a list
|
|
# of latitude/longitude points that represent the vertices of a polygon. The
|
|
# first and last points must be the same. Thus, a minimum of four points is
|
|
# required. The following polygon restrictions from RFC5491 apply:
|
|
# - A connecting line shall not cross another connecting line of the same
|
|
# polygon.
|
|
# - The vertices must be defined in a counterclockwise order.
|
|
# - The edges of a polygon are defined by the shortest path between two points
|
|
# in space (not a geodesic curve). Consequently, the length between two adjacent
|
|
# vertices should be restricted to a maximum of 130 km.
|
|
# - All vertices are assumed to be at the same altitude.
|
|
# - Polygon shapes should be restricted to a maximum of 15 vertices (16 points
|
|
# that include the repeated vertex).
|
|
# Corresponds to the JSON property `exterior`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::GeoLocationPoint>]
|
|
attr_accessor :exterior
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@exterior = args[:exterior] if args.key?(:exterior)
|
|
end
|
|
end
|
|
|
|
# The schedule of spectrum profiles available at a particular geolocation.
|
|
class GeoSpectrumSchedule
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
# Corresponds to the JSON property `location`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocation]
|
|
attr_accessor :location
|
|
|
|
# A list of available spectrum profiles and associated times. It will always be
|
|
# present, and at least one schedule must be included (though it may be empty if
|
|
# there is no available spectrum). More than one schedule may be included to
|
|
# represent future changes to the available spectrum.
|
|
# Corresponds to the JSON property `spectrumSchedules`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::SpectrumSchedule>]
|
|
attr_accessor :spectrum_schedules
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@location = args[:location] if args.key?(:location)
|
|
@spectrum_schedules = args[:spectrum_schedules] if args.key?(:spectrum_schedules)
|
|
end
|
|
end
|
|
|
|
# The request message for a batch available spectrum query protocol.
|
|
class PawsGetSpectrumBatchRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Antenna characteristics provide additional information, such as the antenna
|
|
# height, antenna type, etc. Whether antenna characteristics must be provided in
|
|
# a request depends on the device type and regulatory domain.
|
|
# Corresponds to the JSON property `antenna`
|
|
# @return [Google::Apis::SpectrumV1explorer::AntennaCharacteristics]
|
|
attr_accessor :antenna
|
|
|
|
# Device capabilities provide additional information that may be used by a
|
|
# device to provide additional information to the database that may help it to
|
|
# determine available spectrum. If the database does not support device
|
|
# capabilities it will ignore the parameter altogether.
|
|
# Corresponds to the JSON property `capabilities`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceCapabilities]
|
|
attr_accessor :capabilities
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# A geolocation list is required. This allows a device to specify its current
|
|
# location plus additional anticipated locations when allowed by the regulatory
|
|
# domain. At least one location must be included. Geolocation must be given as
|
|
# the location of the radiation center of the device's antenna. If a location
|
|
# specifies a region, rather than a point, the database may return an
|
|
# UNIMPLEMENTED error if it does not support query by region.
|
|
# There is no upper limit on the number of locations included in a available
|
|
# spectrum batch request, but the database may restrict the number of locations
|
|
# it supports by returning a response with fewer locations than specified in the
|
|
# batch request. Note that geolocations must be those of the master device (a
|
|
# device with geolocation capability that makes an available spectrum batch
|
|
# request), whether the master device is making the request on its own behalf or
|
|
# on behalf of a slave device (one without geolocation capability).
|
|
# Corresponds to the JSON property `locations`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::GeoLocation>]
|
|
attr_accessor :locations
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `masterDeviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :master_device_desc
|
|
|
|
# This parameter contains device-owner information required as part of device
|
|
# registration. The regulatory domains may require additional parameters.
|
|
# All contact information must be expressed using the structure defined by the
|
|
# vCard format specification. Only the contact fields of vCard are supported:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Note that the vCard specification defines maximum lengths for each field.
|
|
# Corresponds to the JSON property `owner`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceOwner]
|
|
attr_accessor :owner
|
|
|
|
# The request type parameter is an optional parameter that can be used to modify
|
|
# an available spectrum batch request, but its use depends on applicable
|
|
# regulatory rules. For example, It may be used to request generic slave device
|
|
# parameters without having to specify the device descriptor for a specific
|
|
# device. When the requestType parameter is missing, the request is for a
|
|
# specific device (master or slave), and the device descriptor parameter for the
|
|
# device on whose behalf the batch request is made is required.
|
|
# Corresponds to the JSON property `requestType`
|
|
# @return [String]
|
|
attr_accessor :request_type
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@antenna = args[:antenna] if args.key?(:antenna)
|
|
@capabilities = args[:capabilities] if args.key?(:capabilities)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@locations = args[:locations] if args.key?(:locations)
|
|
@master_device_desc = args[:master_device_desc] if args.key?(:master_device_desc)
|
|
@owner = args[:owner] if args.key?(:owner)
|
|
@request_type = args[:request_type] if args.key?(:request_type)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The response message for the batch available spectrum query contains a
|
|
# schedule of available spectrum for the device at multiple locations.
|
|
class PawsGetSpectrumBatchResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
# Corresponds to the JSON property `databaseChange`
|
|
# @return [Google::Apis::SpectrumV1explorer::DbUpdateSpec]
|
|
attr_accessor :database_change
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# The available spectrum batch response must contain a geo-spectrum schedule
|
|
# list, The list may be empty if spectrum is not available. The database may
|
|
# return more than one geo-spectrum schedule to represent future changes to the
|
|
# available spectrum. How far in advance a schedule may be provided depends upon
|
|
# the applicable regulatory domain. The database may return available spectrum
|
|
# for fewer geolocations than requested. The device must not make assumptions
|
|
# about the order of the entries in the list, and must use the geolocation value
|
|
# in each geo-spectrum schedule entry to match available spectrum to a location.
|
|
# Corresponds to the JSON property `geoSpectrumSchedules`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::GeoSpectrumSchedule>]
|
|
attr_accessor :geo_spectrum_schedules
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsGetSpectrumBatchResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# The database may return a constraint on the allowed maximum contiguous
|
|
# bandwidth (in Hertz). A regulatory domain may require the database to return
|
|
# this parameter. When this parameter is present in the response, the device
|
|
# must apply this constraint to its spectrum-selection logic to ensure that no
|
|
# single block of spectrum has bandwidth that exceeds this value.
|
|
# Corresponds to the JSON property `maxContiguousBwHz`
|
|
# @return [Float]
|
|
attr_accessor :max_contiguous_bw_hz
|
|
|
|
# The database may return a constraint on the allowed maximum total bandwidth (
|
|
# in Hertz), which does not need to be contiguous. A regulatory domain may
|
|
# require the database to return this parameter. When this parameter is present
|
|
# in the available spectrum batch response, the device must apply this
|
|
# constraint to its spectrum-selection logic to ensure that total bandwidth does
|
|
# not exceed this value.
|
|
# Corresponds to the JSON property `maxTotalBwHz`
|
|
# @return [Float]
|
|
attr_accessor :max_total_bw_hz
|
|
|
|
# For regulatory domains that require a spectrum-usage report from devices, the
|
|
# database must return true for this parameter if the geo-spectrum schedules
|
|
# list is not empty; otherwise, the database should either return false or omit
|
|
# this parameter. If this parameter is present and its value is true, the device
|
|
# must send a spectrum use notify message to the database; otherwise, the device
|
|
# should not send the notification.
|
|
# Corresponds to the JSON property `needsSpectrumReport`
|
|
# @return [Boolean]
|
|
attr_accessor :needs_spectrum_report
|
|
alias_method :needs_spectrum_report?, :needs_spectrum_report
|
|
|
|
# This contains parameters for the ruleset of a regulatory domain that is
|
|
# communicated using the initialization and available-spectrum processes.
|
|
# Corresponds to the JSON property `rulesetInfo`
|
|
# @return [Google::Apis::SpectrumV1explorer::RulesetInfo]
|
|
attr_accessor :ruleset_info
|
|
|
|
# The database includes a timestamp of the form, YYYY-MM-DDThh:mm:ssZ (Internet
|
|
# timestamp format per RFC3339), in its available spectrum batch response. The
|
|
# timestamp should be used by the device as a reference for the start and stop
|
|
# times specified in the response spectrum schedules.
|
|
# Corresponds to the JSON property `timestamp`
|
|
# @return [String]
|
|
attr_accessor :timestamp
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@database_change = args[:database_change] if args.key?(:database_change)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@geo_spectrum_schedules = args[:geo_spectrum_schedules] if args.key?(:geo_spectrum_schedules)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@max_contiguous_bw_hz = args[:max_contiguous_bw_hz] if args.key?(:max_contiguous_bw_hz)
|
|
@max_total_bw_hz = args[:max_total_bw_hz] if args.key?(:max_total_bw_hz)
|
|
@needs_spectrum_report = args[:needs_spectrum_report] if args.key?(:needs_spectrum_report)
|
|
@ruleset_info = args[:ruleset_info] if args.key?(:ruleset_info)
|
|
@timestamp = args[:timestamp] if args.key?(:timestamp)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The request message for the available spectrum query protocol which must
|
|
# include the device's geolocation.
|
|
class PawsGetSpectrumRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Antenna characteristics provide additional information, such as the antenna
|
|
# height, antenna type, etc. Whether antenna characteristics must be provided in
|
|
# a request depends on the device type and regulatory domain.
|
|
# Corresponds to the JSON property `antenna`
|
|
# @return [Google::Apis::SpectrumV1explorer::AntennaCharacteristics]
|
|
attr_accessor :antenna
|
|
|
|
# Device capabilities provide additional information that may be used by a
|
|
# device to provide additional information to the database that may help it to
|
|
# determine available spectrum. If the database does not support device
|
|
# capabilities it will ignore the parameter altogether.
|
|
# Corresponds to the JSON property `capabilities`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceCapabilities]
|
|
attr_accessor :capabilities
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
# Corresponds to the JSON property `location`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocation]
|
|
attr_accessor :location
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `masterDeviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :master_device_desc
|
|
|
|
# This parameter contains device-owner information required as part of device
|
|
# registration. The regulatory domains may require additional parameters.
|
|
# All contact information must be expressed using the structure defined by the
|
|
# vCard format specification. Only the contact fields of vCard are supported:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Note that the vCard specification defines maximum lengths for each field.
|
|
# Corresponds to the JSON property `owner`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceOwner]
|
|
attr_accessor :owner
|
|
|
|
# The request type parameter is an optional parameter that can be used to modify
|
|
# an available spectrum request, but its use depends on applicable regulatory
|
|
# rules. It may be used, for example, to request generic slave device parameters
|
|
# without having to specify the device descriptor for a specific device. When
|
|
# the requestType parameter is missing, the request is for a specific device (
|
|
# master or slave), and the deviceDesc parameter for the device on whose behalf
|
|
# the request is made is required.
|
|
# Corresponds to the JSON property `requestType`
|
|
# @return [String]
|
|
attr_accessor :request_type
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@antenna = args[:antenna] if args.key?(:antenna)
|
|
@capabilities = args[:capabilities] if args.key?(:capabilities)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@location = args[:location] if args.key?(:location)
|
|
@master_device_desc = args[:master_device_desc] if args.key?(:master_device_desc)
|
|
@owner = args[:owner] if args.key?(:owner)
|
|
@request_type = args[:request_type] if args.key?(:request_type)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The response message for the available spectrum query which contains a
|
|
# schedule of available spectrum for the device.
|
|
class PawsGetSpectrumResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
# Corresponds to the JSON property `databaseChange`
|
|
# @return [Google::Apis::SpectrumV1explorer::DbUpdateSpec]
|
|
attr_accessor :database_change
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsGetSpectrumResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# The database may return a constraint on the allowed maximum contiguous
|
|
# bandwidth (in Hertz). A regulatory domain may require the database to return
|
|
# this parameter. When this parameter is present in the response, the device
|
|
# must apply this constraint to its spectrum-selection logic to ensure that no
|
|
# single block of spectrum has bandwidth that exceeds this value.
|
|
# Corresponds to the JSON property `maxContiguousBwHz`
|
|
# @return [Float]
|
|
attr_accessor :max_contiguous_bw_hz
|
|
|
|
# The database may return a constraint on the allowed maximum total bandwidth (
|
|
# in Hertz), which need not be contiguous. A regulatory domain may require the
|
|
# database to return this parameter. When this parameter is present in the
|
|
# available spectrum response, the device must apply this constraint to its
|
|
# spectrum-selection logic to ensure that total bandwidth does not exceed this
|
|
# value.
|
|
# Corresponds to the JSON property `maxTotalBwHz`
|
|
# @return [Float]
|
|
attr_accessor :max_total_bw_hz
|
|
|
|
# For regulatory domains that require a spectrum-usage report from devices, the
|
|
# database must return true for this parameter if the spectrum schedule list is
|
|
# not empty; otherwise, the database will either return false or omit this
|
|
# parameter. If this parameter is present and its value is true, the device must
|
|
# send a spectrum use notify message to the database; otherwise, the device must
|
|
# not send the notification.
|
|
# Corresponds to the JSON property `needsSpectrumReport`
|
|
# @return [Boolean]
|
|
attr_accessor :needs_spectrum_report
|
|
alias_method :needs_spectrum_report?, :needs_spectrum_report
|
|
|
|
# This contains parameters for the ruleset of a regulatory domain that is
|
|
# communicated using the initialization and available-spectrum processes.
|
|
# Corresponds to the JSON property `rulesetInfo`
|
|
# @return [Google::Apis::SpectrumV1explorer::RulesetInfo]
|
|
attr_accessor :ruleset_info
|
|
|
|
# The available spectrum response must contain a spectrum schedule list. The
|
|
# list may be empty if spectrum is not available. The database may return more
|
|
# than one spectrum schedule to represent future changes to the available
|
|
# spectrum. How far in advance a schedule may be provided depends on the
|
|
# applicable regulatory domain.
|
|
# Corresponds to the JSON property `spectrumSchedules`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::SpectrumSchedule>]
|
|
attr_accessor :spectrum_schedules
|
|
|
|
# The database includes a timestamp of the form YYYY-MM-DDThh:mm:ssZ (Internet
|
|
# timestamp format per RFC3339) in its available spectrum response. The
|
|
# timestamp should be used by the device as a reference for the start and stop
|
|
# times specified in the response spectrum schedules.
|
|
# Corresponds to the JSON property `timestamp`
|
|
# @return [String]
|
|
attr_accessor :timestamp
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@database_change = args[:database_change] if args.key?(:database_change)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@max_contiguous_bw_hz = args[:max_contiguous_bw_hz] if args.key?(:max_contiguous_bw_hz)
|
|
@max_total_bw_hz = args[:max_total_bw_hz] if args.key?(:max_total_bw_hz)
|
|
@needs_spectrum_report = args[:needs_spectrum_report] if args.key?(:needs_spectrum_report)
|
|
@ruleset_info = args[:ruleset_info] if args.key?(:ruleset_info)
|
|
@spectrum_schedules = args[:spectrum_schedules] if args.key?(:spectrum_schedules)
|
|
@timestamp = args[:timestamp] if args.key?(:timestamp)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The initialization request message allows the master device to initiate
|
|
# exchange of capabilities with the database.
|
|
class PawsInitRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
# Corresponds to the JSON property `location`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocation]
|
|
attr_accessor :location
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@location = args[:location] if args.key?(:location)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The initialization response message communicates database parameters to the
|
|
# requesting device.
|
|
class PawsInitResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
# Corresponds to the JSON property `databaseChange`
|
|
# @return [Google::Apis::SpectrumV1explorer::DbUpdateSpec]
|
|
attr_accessor :database_change
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsInitResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# This contains parameters for the ruleset of a regulatory domain that is
|
|
# communicated using the initialization and available-spectrum processes.
|
|
# Corresponds to the JSON property `rulesetInfo`
|
|
# @return [Google::Apis::SpectrumV1explorer::RulesetInfo]
|
|
attr_accessor :ruleset_info
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@database_change = args[:database_change] if args.key?(:database_change)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@ruleset_info = args[:ruleset_info] if args.key?(:ruleset_info)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The spectrum-use notification message which must contain the geolocation of
|
|
# the Device and parameters required by the regulatory domain.
|
|
class PawsNotifySpectrumUseRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
# Corresponds to the JSON property `location`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocation]
|
|
attr_accessor :location
|
|
|
|
# A spectrum list is required in the spectrum-use notification. The list
|
|
# specifies the spectrum that the device expects to use, which includes
|
|
# frequency ranges and maximum power levels. The list may be empty if the device
|
|
# decides not to use any of spectrum. For consistency, the psdBandwidthHz value
|
|
# should match that from one of the spectrum elements in the corresponding
|
|
# available spectrum response previously sent to the device by the database.
|
|
# Note that maximum power levels in the spectrum element must be expressed as
|
|
# power spectral density over the specified psdBandwidthHz value. The actual
|
|
# bandwidth to be used (as computed from the start and stop frequencies) may be
|
|
# different from the psdBandwidthHz value. As an example, when regulatory rules
|
|
# express maximum power spectral density in terms of maximum power over any 100
|
|
# kHz band, then the psdBandwidthHz value should be set to 100 kHz, even though
|
|
# the actual bandwidth used can be 20 kHz.
|
|
# Corresponds to the JSON property `spectra`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::SpectrumMessage>]
|
|
attr_accessor :spectra
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@location = args[:location] if args.key?(:location)
|
|
@spectra = args[:spectra] if args.key?(:spectra)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# An empty response to the notification.
|
|
class PawsNotifySpectrumUseResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsNotifySpectrumUseResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The registration request message contains the required registration parameters.
|
|
class PawsRegisterRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Antenna characteristics provide additional information, such as the antenna
|
|
# height, antenna type, etc. Whether antenna characteristics must be provided in
|
|
# a request depends on the device type and regulatory domain.
|
|
# Corresponds to the JSON property `antenna`
|
|
# @return [Google::Apis::SpectrumV1explorer::AntennaCharacteristics]
|
|
attr_accessor :antenna
|
|
|
|
# The device descriptor contains parameters that identify the specific device,
|
|
# such as its manufacturer serial number, regulatory-specific identifier (e.g.,
|
|
# FCC ID), and any other device characteristics required by regulatory domains.
|
|
# Corresponds to the JSON property `deviceDesc`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceDescriptor]
|
|
attr_accessor :device_desc
|
|
|
|
# This parameter contains device-owner information required as part of device
|
|
# registration. The regulatory domains may require additional parameters.
|
|
# All contact information must be expressed using the structure defined by the
|
|
# vCard format specification. Only the contact fields of vCard are supported:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
# Note that the vCard specification defines maximum lengths for each field.
|
|
# Corresponds to the JSON property `deviceOwner`
|
|
# @return [Google::Apis::SpectrumV1explorer::DeviceOwner]
|
|
attr_accessor :device_owner
|
|
|
|
# This parameter is used to specify the geolocation of the device.
|
|
# Corresponds to the JSON property `location`
|
|
# @return [Google::Apis::SpectrumV1explorer::GeoLocation]
|
|
attr_accessor :location
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@antenna = args[:antenna] if args.key?(:antenna)
|
|
@device_desc = args[:device_desc] if args.key?(:device_desc)
|
|
@device_owner = args[:device_owner] if args.key?(:device_owner)
|
|
@location = args[:location] if args.key?(:location)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The registration response message simply acknowledges receipt of the request
|
|
# and is otherwise empty.
|
|
class PawsRegisterResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
# Corresponds to the JSON property `databaseChange`
|
|
# @return [Google::Apis::SpectrumV1explorer::DbUpdateSpec]
|
|
attr_accessor :database_change
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsRegisterResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@database_change = args[:database_change] if args.key?(:database_change)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The device validation request message.
|
|
class PawsVerifyDeviceRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A list of device descriptors, which specifies the slave devices to be
|
|
# validated, is required.
|
|
# Corresponds to the JSON property `deviceDescs`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::DeviceDescriptor>]
|
|
attr_accessor :device_descs
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@device_descs = args[:device_descs] if args.key?(:device_descs)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# The device validation response message.
|
|
class PawsVerifyDeviceResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# This message is provided by the database to notify devices of an upcoming
|
|
# change to the database URI.
|
|
# Corresponds to the JSON property `databaseChange`
|
|
# @return [Google::Apis::SpectrumV1explorer::DbUpdateSpec]
|
|
attr_accessor :database_change
|
|
|
|
# A device validities list is required in the device validation response to
|
|
# report whether each slave device listed in a previous device validation
|
|
# request is valid. The number of entries must match the number of device
|
|
# descriptors listed in the previous device validation request.
|
|
# Corresponds to the JSON property `deviceValidities`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::DeviceValidity>]
|
|
attr_accessor :device_validities
|
|
|
|
# Identifies what kind of resource this is. Value: the fixed string "spectrum#
|
|
# pawsVerifyDeviceResponse".
|
|
# Corresponds to the JSON property `kind`
|
|
# @return [String]
|
|
attr_accessor :kind
|
|
|
|
# The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
|
|
# Required field.
|
|
# Corresponds to the JSON property `type`
|
|
# @return [String]
|
|
attr_accessor :type
|
|
|
|
# The PAWS version. Must be exactly 1.0.
|
|
# Required field.
|
|
# Corresponds to the JSON property `version`
|
|
# @return [String]
|
|
attr_accessor :version
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@database_change = args[:database_change] if args.key?(:database_change)
|
|
@device_validities = args[:device_validities] if args.key?(:device_validities)
|
|
@kind = args[:kind] if args.key?(:kind)
|
|
@type = args[:type] if args.key?(:type)
|
|
@version = args[:version] if args.key?(:version)
|
|
end
|
|
end
|
|
|
|
# This contains parameters for the ruleset of a regulatory domain that is
|
|
# communicated using the initialization and available-spectrum processes.
|
|
class RulesetInfo
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The regulatory domain to which the ruleset belongs is required. It must be a 2-
|
|
# letter country code. The device should use this to determine additional device
|
|
# behavior required by the associated regulatory domain.
|
|
# Corresponds to the JSON property `authority`
|
|
# @return [String]
|
|
attr_accessor :authority
|
|
|
|
# The maximum location change in meters is required in the initialization
|
|
# response, but optional otherwise. When the device changes location by more
|
|
# than this specified distance, it must contact the database to get the
|
|
# available spectrum for the new location. If the device is using spectrum that
|
|
# is no longer available, it must immediately cease use of the spectrum under
|
|
# rules for database-managed spectrum. If this value is provided within the
|
|
# context of an available-spectrum response, it takes precedence over the value
|
|
# within the initialization response.
|
|
# Corresponds to the JSON property `maxLocationChange`
|
|
# @return [Float]
|
|
attr_accessor :max_location_change
|
|
|
|
# The maximum duration, in seconds, between requests for available spectrum. It
|
|
# is required in the initialization response, but optional otherwise. The device
|
|
# must contact the database to get available spectrum no less frequently than
|
|
# this duration. If the new spectrum information indicates that the device is
|
|
# using spectrum that is no longer available, it must immediately cease use of
|
|
# those frequencies under rules for database-managed spectrum. If this value is
|
|
# provided within the context of an available-spectrum response, it takes
|
|
# precedence over the value within the initialization response.
|
|
# Corresponds to the JSON property `maxPollingSecs`
|
|
# @return [Fixnum]
|
|
attr_accessor :max_polling_secs
|
|
|
|
# The identifiers of the rulesets supported for the device's location. The
|
|
# database should include at least one applicable ruleset in the initialization
|
|
# response. The device may use the ruleset identifiers to determine parameters
|
|
# to include in subsequent requests. Within the context of the available-
|
|
# spectrum responses, the database should include the identifier of the ruleset
|
|
# that it used to determine the available-spectrum response. If included, the
|
|
# device must use the specified ruleset to interpret the response. If the device
|
|
# does not support the indicated ruleset, it must not operate in the spectrum
|
|
# governed by the ruleset.
|
|
# Corresponds to the JSON property `rulesetIds`
|
|
# @return [Array<String>]
|
|
attr_accessor :ruleset_ids
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@authority = args[:authority] if args.key?(:authority)
|
|
@max_location_change = args[:max_location_change] if args.key?(:max_location_change)
|
|
@max_polling_secs = args[:max_polling_secs] if args.key?(:max_polling_secs)
|
|
@ruleset_ids = args[:ruleset_ids] if args.key?(:ruleset_ids)
|
|
end
|
|
end
|
|
|
|
# Available spectrum can be logically characterized by a list of frequency
|
|
# ranges and permissible power levels for each range.
|
|
class SpectrumMessage
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The bandwidth (in Hertz) for which permissible power levels are specified. For
|
|
# example, FCC regulation would require only one spectrum specification at 6MHz
|
|
# bandwidth, but Ofcom regulation would require two specifications, at 0.1MHz
|
|
# and 8MHz. This parameter may be empty if there is no available spectrum. It
|
|
# will be present otherwise.
|
|
# Corresponds to the JSON property `bandwidth`
|
|
# @return [Float]
|
|
attr_accessor :bandwidth
|
|
|
|
# The list of frequency ranges and permissible power levels. The list may be
|
|
# empty if there is no available spectrum, otherwise it will be present.
|
|
# Corresponds to the JSON property `frequencyRanges`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::FrequencyRange>]
|
|
attr_accessor :frequency_ranges
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@bandwidth = args[:bandwidth] if args.key?(:bandwidth)
|
|
@frequency_ranges = args[:frequency_ranges] if args.key?(:frequency_ranges)
|
|
end
|
|
end
|
|
|
|
# The spectrum schedule element combines an event time with spectrum profile to
|
|
# define a time period in which the profile is valid.
|
|
class SpectrumSchedule
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The start and stop times of an event. This is used to indicate the time period
|
|
# for which a spectrum profile is valid.
|
|
# Both times are expressed using the format, YYYY-MM-DDThh:mm:ssZ, as defined in
|
|
# RFC3339. The times must be expressed using UTC.
|
|
# Corresponds to the JSON property `eventTime`
|
|
# @return [Google::Apis::SpectrumV1explorer::EventTime]
|
|
attr_accessor :event_time
|
|
|
|
# A list of spectrum messages representing the usable profile. It will always be
|
|
# present, but may be empty when there is no available spectrum.
|
|
# Corresponds to the JSON property `spectra`
|
|
# @return [Array<Google::Apis::SpectrumV1explorer::SpectrumMessage>]
|
|
attr_accessor :spectra
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@event_time = args[:event_time] if args.key?(:event_time)
|
|
@spectra = args[:spectra] if args.key?(:spectra)
|
|
end
|
|
end
|
|
|
|
# A vCard-in-JSON message that contains only the fields needed for PAWS:
|
|
# - fn: Full name of an individual
|
|
# - org: Name of the organization
|
|
# - adr: Address fields
|
|
# - tel: Telephone numbers
|
|
# - email: Email addresses
|
|
class Vcard
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The structure used to represent a street address.
|
|
# Corresponds to the JSON property `adr`
|
|
# @return [Google::Apis::SpectrumV1explorer::VcardAddress]
|
|
attr_accessor :adr
|
|
|
|
# The structure used to represent an organization and an email address.
|
|
# Corresponds to the JSON property `email`
|
|
# @return [Google::Apis::SpectrumV1explorer::VcardTypedText]
|
|
attr_accessor :email
|
|
|
|
# The full name of the contact person. For example: John A. Smith.
|
|
# Corresponds to the JSON property `fn`
|
|
# @return [String]
|
|
attr_accessor :fn
|
|
|
|
# The structure used to represent an organization and an email address.
|
|
# Corresponds to the JSON property `org`
|
|
# @return [Google::Apis::SpectrumV1explorer::VcardTypedText]
|
|
attr_accessor :org
|
|
|
|
# The structure used to represent a telephone number.
|
|
# Corresponds to the JSON property `tel`
|
|
# @return [Google::Apis::SpectrumV1explorer::VcardTelephone]
|
|
attr_accessor :tel
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@adr = args[:adr] if args.key?(:adr)
|
|
@email = args[:email] if args.key?(:email)
|
|
@fn = args[:fn] if args.key?(:fn)
|
|
@org = args[:org] if args.key?(:org)
|
|
@tel = args[:tel] if args.key?(:tel)
|
|
end
|
|
end
|
|
|
|
# The structure used to represent a street address.
|
|
class VcardAddress
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The postal code associated with the address. For example: 94423.
|
|
# Corresponds to the JSON property `code`
|
|
# @return [String]
|
|
attr_accessor :code
|
|
|
|
# The country name. For example: US.
|
|
# Corresponds to the JSON property `country`
|
|
# @return [String]
|
|
attr_accessor :country
|
|
|
|
# The city or local equivalent portion of the address. For example: San Jose.
|
|
# Corresponds to the JSON property `locality`
|
|
# @return [String]
|
|
attr_accessor :locality
|
|
|
|
# An optional post office box number.
|
|
# Corresponds to the JSON property `pobox`
|
|
# @return [String]
|
|
attr_accessor :pobox
|
|
|
|
# The state or local equivalent portion of the address. For example: CA.
|
|
# Corresponds to the JSON property `region`
|
|
# @return [String]
|
|
attr_accessor :region
|
|
|
|
# The street number and name. For example: 123 Any St.
|
|
# Corresponds to the JSON property `street`
|
|
# @return [String]
|
|
attr_accessor :street
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@code = args[:code] if args.key?(:code)
|
|
@country = args[:country] if args.key?(:country)
|
|
@locality = args[:locality] if args.key?(:locality)
|
|
@pobox = args[:pobox] if args.key?(:pobox)
|
|
@region = args[:region] if args.key?(:region)
|
|
@street = args[:street] if args.key?(:street)
|
|
end
|
|
end
|
|
|
|
# The structure used to represent a telephone number.
|
|
class VcardTelephone
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A nested telephone URI of the form: tel:+1-123-456-7890.
|
|
# Corresponds to the JSON property `uri`
|
|
# @return [String]
|
|
attr_accessor :uri
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@uri = args[:uri] if args.key?(:uri)
|
|
end
|
|
end
|
|
|
|
# The structure used to represent an organization and an email address.
|
|
class VcardTypedText
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The text string associated with this item. For example, for an org field: ACME,
|
|
# inc. For an email field: smith@example.com.
|
|
# Corresponds to the JSON property `text`
|
|
# @return [String]
|
|
attr_accessor :text
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@text = args[:text] if args.key?(:text)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|