googleapis
Version:
Google APIs Client Library for Node.js
1,185 lines • 50.5 kB
TypeScript
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* 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.
*/
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
* Google Spectrum Database API
*
* API for spectrum-management functions.
*
* @example
* const google = require('googleapis');
* const spectrum = google.spectrum('v1explorer');
*
* @namespace spectrum
* @type {Function}
* @version v1explorer
* @variation v1explorer
* @param {object=} options Options for Spectrum
*/
export declare class Spectrum {
_options: GlobalOptions;
google: GoogleApis;
root: this;
paws: Resource$Paws;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
/**
* 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.
*/
export interface Schema$AntennaCharacteristics {
/**
* 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.
*/
height: number;
/**
* 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.
*/
heightType: string;
/**
* The height uncertainty in meters. Whether this is required depends on the
* regulatory domain.
*/
heightUncertainty: number;
}
/**
* This message contains the name and URI of a database.
*/
export interface Schema$DatabaseSpec {
/**
* The display name for a database.
*/
name: string;
/**
* The corresponding URI of the database.
*/
uri: string;
}
/**
* This message is provided by the database to notify devices of an upcoming
* change to the database URI.
*/
export interface Schema$DbUpdateSpec {
/**
* 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.
*/
databases: Schema$DatabaseSpec[];
}
/**
* 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.
*/
export interface Schema$DeviceCapabilities {
/**
* 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.
*/
frequencyRanges: Schema$FrequencyRange[];
}
/**
* 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.
*/
export interface Schema$DeviceDescriptor {
/**
* 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.
*/
etsiEnDeviceCategory: string;
/**
* 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.
*/
etsiEnDeviceEmissionsClass: string;
/**
* 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.
*/
etsiEnDeviceType: string;
/**
* 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.
*/
etsiEnTechnologyId: string;
/**
* 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.
*/
fccId: string;
/**
* Specifies the TV Band White Space device type, as defined by the FCC. Valid
* values are FIXED, MODE_1, MODE_2.
*/
fccTvbdDeviceType: string;
/**
* 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.
*/
manufacturerId: string;
/**
* The device's model ID may be required by the regulatory domain. The
* string value must not exceed 64 characters in length.
*/
modelId: string;
/**
* 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.
*/
rulesetIds: string[];
/**
* The manufacturer's device serial number; required by the applicable
* regulatory domain. The length of the value must not exceed 64 characters.
*/
serialNumber: string;
}
/**
* 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.
*/
export interface Schema$DeviceOwner {
/**
* The vCard contact information for the device operator is optional, but may
* be required by specific regulatory domains.
*/
operator: Schema$Vcard;
/**
* The vCard contact information for the individual or business that owns the
* device is required.
*/
owner: Schema$Vcard;
}
/**
* The device validity element describes whether a particular device is valid to
* operate in the regulatory domain.
*/
export interface Schema$DeviceValidity {
/**
* The descriptor of the device for which the validity check was requested. It
* will always be present.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* The validity status: true if the device is valid for operation, false
* otherwise. It will always be present.
*/
isValid: boolean;
/**
* 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.
*/
reason: string;
}
/**
* 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.
*/
export interface Schema$EventTime {
/**
* The inclusive start of the event. It will be present.
*/
startTime: string;
/**
* The exclusive end of the event. It will be present.
*/
stopTime: string;
}
/**
* A specific range of frequencies together with the associated maximum power
* level and channel identifier.
*/
export interface Schema$FrequencyRange {
/**
* 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.
*/
channelId: string;
/**
* 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.
*/
maxPowerDBm: number;
/**
* The required inclusive start of the frequency range (in Hertz).
*/
startHz: number;
/**
* The required exclusive end of the frequency range (in Hertz).
*/
stopHz: number;
}
/**
* This parameter is used to specify the geolocation of the device.
*/
export interface Schema$GeoLocation {
/**
* 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.
*/
confidence: number;
/**
* If present, indicates that the geolocation represents a point.
* Paradoxically, a point is parameterized using an ellipse, where the center
* represents the location of the point and the distances along the major and
* minor axes represent the uncertainty. The uncertainty values may be
* required, depending on the regulatory domain.
*/
point: Schema$GeoLocationEllipse;
/**
* If present, indicates that the geolocation represents a region. Database
* support for regions is optional.
*/
region: Schema$GeoLocationPolygon;
}
/**
* A "point" with uncertainty is represented using the Ellipse shape.
*/
export interface Schema$GeoLocationEllipse {
/**
* A required geo-spatial point representing the center of the ellipse.
*/
center: Schema$GeoLocationPoint;
/**
* 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.
*/
orientation: number;
/**
* 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.
*/
semiMajorAxis: number;
/**
* 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.
*/
semiMinorAxis: number;
}
/**
* A single geolocation on the globe.
*/
export interface Schema$GeoLocationPoint {
/**
* 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.
*/
latitude: number;
/**
* 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.
*/
longitude: number;
}
/**
* A region is represented using the polygonal shape.
*/
export interface Schema$GeoLocationPolygon {
/**
* 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).
*/
exterior: Schema$GeoLocationPoint[];
}
/**
* The schedule of spectrum profiles available at a particular geolocation.
*/
export interface Schema$GeoSpectrumSchedule {
/**
* The geolocation identifies the location at which the spectrum schedule
* applies. It will always be present.
*/
location: Schema$GeoLocation;
/**
* 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.
*/
spectrumSchedules: Schema$SpectrumSchedule[];
}
/**
* The request message for a batch available spectrum query protocol.
*/
export interface Schema$PawsGetSpectrumBatchRequest {
/**
* Depending on device type and regulatory domain, antenna characteristics may
* be required.
*/
antenna: Schema$AntennaCharacteristics;
/**
* The master device may include its device capabilities to limit the
* available-spectrum batch response to the spectrum that is compatible with
* its capabilities. The database should not return spectrum that is
* incompatible with the specified capabilities.
*/
capabilities: Schema$DeviceCapabilities;
/**
* When the available spectrum request is made on behalf of a specific device
* (a master or slave device), device descriptor information for the device on
* whose behalf the request is made is required (in such cases, the
* requestType parameter must be empty). When a requestType value is
* specified, device descriptor information may be optional or required
* according to the rules of the applicable regulatory domain.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* 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).
*/
locations: Schema$GeoLocation[];
/**
* When an available spectrum batch request is made by the master device (a
* device with geolocation capability) on behalf of a slave device (a device
* without geolocation capability), the rules of the applicable regulatory
* domain may require the master device to provide its own device descriptor
* information (in addition to device descriptor information for the slave
* device in a separate parameter).
*/
masterDeviceDesc: Schema$DeviceDescriptor;
/**
* Depending on device type and regulatory domain, device owner information
* may be included in an available spectrum batch request. This allows the
* device to register and get spectrum-availability information in a single
* request.
*/
owner: Schema$DeviceOwner;
/**
* 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.
*/
requestType: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The response message for the batch available spectrum query contains a
* schedule of available spectrum for the device at multiple locations.
*/
export interface Schema$PawsGetSpectrumBatchResponse {
/**
* A database may include the databaseChange parameter to notify a device of a
* change to its database URI, providing one or more alternate database URIs.
* The device should use this information to update its list of pre-configured
* databases by (only) replacing its entry for the responding database with
* the list of alternate URIs.
*/
databaseChange: Schema$DbUpdateSpec;
/**
* The database must return in its available spectrum response the device
* descriptor information it received in the master device's available
* spectrum batch request.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* 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.
*/
geoSpectrumSchedules: Schema$GeoSpectrumSchedule[];
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsGetSpectrumBatchResponse".
*/
kind: string;
/**
* 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.
*/
maxContiguousBwHz: number;
/**
* 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.
*/
maxTotalBwHz: number;
/**
* 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.
*/
needsSpectrumReport: boolean;
/**
* The database should return ruleset information, which identifies the
* applicable regulatory authority and ruleset for the available spectrum
* batch response. If included, the device must use the corresponding ruleset
* to interpret the response. Values provided in the returned ruleset
* information, such as maxLocationChange, take precedence over any
* conflicting values provided in the ruleset information returned in a prior
* initialization response sent by the database to the device.
*/
rulesetInfo: Schema$RulesetInfo;
/**
* 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.
*/
timestamp: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The request message for the available spectrum query protocol which must
* include the device's geolocation.
*/
export interface Schema$PawsGetSpectrumRequest {
/**
* Depending on device type and regulatory domain, the characteristics of the
* antenna may be required.
*/
antenna: Schema$AntennaCharacteristics;
/**
* The master device may include its device capabilities to limit the
* available-spectrum response to the spectrum that is compatible with its
* capabilities. The database should not return spectrum that is incompatible
* with the specified capabilities.
*/
capabilities: Schema$DeviceCapabilities;
/**
* When the available spectrum request is made on behalf of a specific device
* (a master or slave device), device descriptor information for that device
* is required (in such cases, the requestType parameter must be empty). When
* a requestType value is specified, device descriptor information may be
* optional or required according to the rules of the applicable regulatory
* domain.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* The geolocation of the master device (a device with geolocation capability
* that makes an available spectrum request) is required whether the master
* device is making the request on its own behalf or on behalf of a slave
* device (one without geolocation capability). The location must be the
* location of the radiation center of the master device's antenna. To
* support mobile devices, a regulatory domain may allow the anticipated
* position of the master device to be given instead. If the location
* specifies a region, rather than a point, the database may return an
* UNIMPLEMENTED error code if it does not support query by region.
*/
location: Schema$GeoLocation;
/**
* When an available spectrum request is made by the master device (a device
* with geolocation capability) on behalf of a slave device (a device without
* geolocation capability), the rules of the applicable regulatory domain may
* require the master device to provide its own device descriptor information
* (in addition to device descriptor information for the slave device, which
* is provided in a separate parameter).
*/
masterDeviceDesc: Schema$DeviceDescriptor;
/**
* Depending on device type and regulatory domain, device owner information
* may be included in an available spectrum request. This allows the device to
* register and get spectrum-availability information in a single request.
*/
owner: Schema$DeviceOwner;
/**
* 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.
*/
requestType: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The response message for the available spectrum query which contains a
* schedule of available spectrum for the device.
*/
export interface Schema$PawsGetSpectrumResponse {
/**
* A database may include the databaseChange parameter to notify a device of a
* change to its database URI, providing one or more alternate database URIs.
* The device should use this information to update its list of pre-configured
* databases by (only) replacing its entry for the responding database with
* the list of alternate URIs.
*/
databaseChange: Schema$DbUpdateSpec;
/**
* The database must return, in its available spectrum response, the device
* descriptor information it received in the master device's available
* spectrum request.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsGetSpectrumResponse".
*/
kind: string;
/**
* 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.
*/
maxContiguousBwHz: number;
/**
* 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.
*/
maxTotalBwHz: number;
/**
* 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.
*/
needsSpectrumReport: boolean;
/**
* The database should return ruleset information, which identifies the
* applicable regulatory authority and ruleset for the available spectrum
* response. If included, the device must use the corresponding ruleset to
* interpret the response. Values provided in the returned ruleset
* information, such as maxLocationChange, take precedence over any
* conflicting values provided in the ruleset information returned in a prior
* initialization response sent by the database to the device.
*/
rulesetInfo: Schema$RulesetInfo;
/**
* 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.
*/
spectrumSchedules: Schema$SpectrumSchedule[];
/**
* 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.
*/
timestamp: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The initialization request message allows the master device to initiate
* exchange of capabilities with the database.
*/
export interface Schema$PawsInitRequest {
/**
* The DeviceDescriptor parameter is required. If the database does not
* support the device or any of the rulesets specified in the device
* descriptor, it must return an UNSUPPORTED error code in the error response.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* A device's geolocation is required.
*/
location: Schema$GeoLocation;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The initialization response message communicates database parameters to the
* requesting device.
*/
export interface Schema$PawsInitResponse {
/**
* A database may include the databaseChange parameter to notify a device of a
* change to its database URI, providing one or more alternate database URIs.
* The device should use this information to update its list of pre-configured
* databases by (only) replacing its entry for the responding database with
* the list of alternate URIs.
*/
databaseChange: Schema$DbUpdateSpec;
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsInitResponse".
*/
kind: string;
/**
* The rulesetInfo parameter must be included in the response. This parameter
* specifies the regulatory domain and parameters applicable to that domain.
* The database must include the authority field, which defines the regulatory
* domain for the location specified in the INIT_REQ message.
*/
rulesetInfo: Schema$RulesetInfo;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The spectrum-use notification message which must contain the geolocation of
* the Device and parameters required by the regulatory domain.
*/
export interface Schema$PawsNotifySpectrumUseRequest {
/**
* Device descriptor information is required in the spectrum-use notification
* message.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* The geolocation of the master device (the device that is sending the
* spectrum-use notification) to the database is required in the spectrum-use
* notification message.
*/
location: Schema$GeoLocation;
/**
* 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.
*/
spectra: Schema$SpectrumMessage[];
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* An empty response to the notification.
*/
export interface Schema$PawsNotifySpectrumUseResponse {
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsNotifySpectrumUseResponse".
*/
kind: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The registration request message contains the required registration
* parameters.
*/
export interface Schema$PawsRegisterRequest {
/**
* Antenna characteristics, including its height and height type.
*/
antenna: Schema$AntennaCharacteristics;
/**
* A DeviceDescriptor is required.
*/
deviceDesc: Schema$DeviceDescriptor;
/**
* Device owner information is required.
*/
deviceOwner: Schema$DeviceOwner;
/**
* A device's geolocation is required.
*/
location: Schema$GeoLocation;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The registration response message simply acknowledges receipt of the request
* and is otherwise empty.
*/
export interface Schema$PawsRegisterResponse {
/**
* A database may include the databaseChange parameter to notify a device of a
* change to its database URI, providing one or more alternate database URIs.
* The device should use this information to update its list of pre-configured
* databases by (only) replacing its entry for the responding database with
* the list of alternate URIs.
*/
databaseChange: Schema$DbUpdateSpec;
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsRegisterResponse".
*/
kind: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The device validation request message.
*/
export interface Schema$PawsVerifyDeviceRequest {
/**
* A list of device descriptors, which specifies the slave devices to be
* validated, is required.
*/
deviceDescs: Schema$DeviceDescriptor[];
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* The device validation response message.
*/
export interface Schema$PawsVerifyDeviceResponse {
/**
* A database may include the databaseChange parameter to notify a device of a
* change to its database URI, providing one or more alternate database URIs.
* The device should use this information to update its list of pre-configured
* databases by (only) replacing its entry for the responding database with
* the list of alternate URIs.
*/
databaseChange: Schema$DbUpdateSpec;
/**
* 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.
*/
deviceValidities: Schema$DeviceValidity[];
/**
* Identifies what kind of resource this is. Value: the fixed string
* "spectrum#pawsVerifyDeviceResponse".
*/
kind: string;
/**
* The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...). Required
* field.
*/
type: string;
/**
* The PAWS version. Must be exactly 1.0. Required field.
*/
version: string;
}
/**
* This contains parameters for the ruleset of a regulatory domain that is
* communicated using the initialization and available-spectrum processes.
*/
export interface Schema$RulesetInfo {
/**
* 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.
*/
authority: string;
/**
* 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.
*/
maxLocationChange: number;
/**
* 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.
*/
maxPollingSecs: number;
/**
* 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.
*/
rulesetIds: string[];
}
/**
* Available spectrum can be logically characterized by a list of frequency
* ranges and permissible power levels for each range.
*/
export interface Schema$SpectrumMessage {
/**
* 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.
*/
bandwidth: number;
/**
* 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.
*/
frequencyRanges: Schema$FrequencyRange[];
}
/**
* The spectrum schedule element combines an event time with spectrum profile to
* define a time period in which the profile is valid.
*/
export interface Schema$SpectrumSchedule {
/**
* The event time expresses when the spectrum profile is valid. It will always
* be present.
*/
eventTime: Schema$EventTime;
/**
* A list of spectrum messages representing the usable profile. It will always
* be present, but may be empty when there is no available spectrum.
*/
spectra: Schema$SpectrumMessage[];
}
/**
* 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
*/
export interface Schema$Vcard {
/**
* The street address of the entity.
*/
adr: Schema$VcardAddress;
/**
* An email address that can be used to reach the contact.
*/
email: Schema$VcardTypedText;
/**
* The full name of the contact person. For example: John A. Smith.
*/
fn: string;
/**
* The organization associated with the registering entity.
*/
org: Schema$VcardTypedText;
/**
* A telephone number that can be used to call the contact.
*/
tel: Schema$VcardTelephone;
}
/**
* The structure used to represent a street address.
*/
export interface Schema$VcardAddress {
/**
* The postal code associated with the address. For example: 94423.
*/
code: string;
/**
* The country name. For example: US.
*/
country: string;
/**
* The city or local equivalent portion of the address. For example: San Jose.
*/
locality: string;
/**
* An optional post office box number.
*/
pobox: string;
/**
* The state or local equivalent portion of the address. For example: CA.
*/
region: string;
/**
* The street number and name. For example: 123 Any St.
*/
street: string;
}
/**
* The structure used to represent a telephone number.
*/
export interface Schema$VcardTelephone {
/**
* A nested telephone URI of the form: tel:+1-123-456-7890.
*/
uri: string;
}
/**
* The structure used to represent an organization and an email address.
*/
export interface Schema$VcardTypedText {
/**
* The text string associated with this item. For example, for an org field:
* ACME, inc. For an email field: smith@example.com.
*/
text: string;
}
export declare class Resource$Paws {
root: Spectrum;
constructor(root: Spectrum);
getRoot(): Spectrum;
/**
* spectrum.paws.getSpectrum
* @desc Requests information about the available spectrum for a device at a
* location. Requests from a fixed-mode device must include owner information
* so the device can be registered with the database.
* @alias spectrum.paws.getSpectrum
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsGetSpectrumRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
getSpectrum(params?: any, options?: MethodOptions): AxiosPromise<Schema$PawsGetSpectrumResponse>;
getSpectrum(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$PawsGetSpectrumResponse>, callback?: BodyResponseCallback<Schema$PawsGetSpectrumResponse>): void;
/**
* spectrum.paws.getSpectrumBatch
* @desc The Google Spectrum Database does not support batch requests, so this
* method always yields an UNIMPLEMENTED error.
* @alias spectrum.paws.getSpectrumBatch
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsGetSpectrumBatchRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
getSpectrumBatch(params?: any, options?: MethodOptions): AxiosPromise<Schema$PawsGetSpectrumBatchResponse>;
getSpectrumBatch(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$PawsGetSpectrumBatchResponse>, callback?: BodyResponseCallback<Schema$PawsGetSpectrumBatchResponse>): void;
/**
* spectrum.paws.init
* @desc Initializes the connection between a white space device and the
* database.
* @alias spectrum.paws.init
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsInitRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
init(params?: any, options?: MethodOptions): AxiosPromise<Schema$PawsInitResponse>;
init(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$PawsInitResponse>, callback?: BodyResponseCallback<Schema$PawsInitResponse>): void;
/**
* spectrum.paws.notifySpectrumUse
* @desc Notifies the database that the device has selected certain frequency
* ranges for transmission. Only to be invoked when required by the regulator.
* The Google Spectrum Database does not operate in domains that require
* notification, so this always yields an UNIMPLEMENTED error.
* @alias spectrum.paws.notifySpectrumUse
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsNotifySpectrumUseRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
notifySpectrumUse(params?: any, options?: MethodOptions): AxiosPromise<Schema$PawsNotifySpectrumUseResponse>;
notifySpectrumUse(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$PawsNotifySpectrumUseResponse>, callback?: BodyResponseCallback<Schema$PawsNotifySpectrumUseResponse>): void;
/**
* spectrum.paws.register
* @desc The Google Spectrum Database implements registration in the
* getSpectrum method. As such this always returns an UNIMPLEMENTED error.
* @alias spectrum.paws.register
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsRegisterRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
register(params?: any, options?: MethodOptions): AxiosPromise<Schema$PawsRegisterResponse>;
register(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$PawsRegisterResponse>, callback?: BodyResponseCallback<Schema$PawsRegisterResponse>): void;
/**
* spectrum.paws.verifyDevice
* @desc Validates a device for white space use in accordance with regulatory
* rules. The Google Spectrum Database does not support master/slave
* configurations, so this always yields an UNIMPLEMENTED error.
* @alias spectrum.paws.verifyDevice
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().PawsVerifyDeviceRequest} params.resource Request body data
* @param {objec