Api-roll 37: 2016-06-06

generated/googleapis_beta/lib/proximitybeacon/v1beta1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.proximitybeacon.v1beta1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
-import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
 
 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
     ApiRequestError, DetailedApiRequestError;
 
 const core.String USER_AGENT = 'dart-api-client proximitybeacon/v1beta1';
 
 /** Registers, manages, indexes, and searches beacons. */
 class ProximitybeaconApi {
   /** View and modify your beacons */
@@ skipping 1050 matching lines @@
 class AdvertisedId {
   /**
    * The actual beacon identifier, as broadcast by the beacon hardware. Must be
    * [base64](http://tools.ietf.org/html/rfc4648#section-4) encoded in HTTP
    * requests, and will be so encoded (with padding) in responses. The base64
    * encoding should be of the binary byte-stream and not any textual (such as
    * hex) representation thereof. Required.
    */
   core.String id;
   core.List<core.int> get idAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(id);
+    return convert.BASE64.decode(id);
   }
 
   void set idAsBytes(core.List<core.int> _bytes) {
-    id = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    id = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Specifies the identifier type. Required.
    * Possible string values are:
    * - "TYPE_UNSPECIFIED" : A TYPE_UNSPECIFIED.
    * - "EDDYSTONE" : A EDDYSTONE.
    * - "IBEACON" : A IBEACON.
    * - "ALTBEACON" : A ALTBEACON.
    * - "EDDYSTONE_EID" : A EDDYSTONE_EID.
    */
@@ skipping 23 matching lines @@
 }
 
 /**
  * A subset of attachment information served via the `beaconinfo.getforobserved`
  * method, used when your users encounter your beacons.
  */
 class AttachmentInfo {
   /** An opaque data container for client-provided data. */
   core.String data;
   core.List<core.int> get dataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(data);
+    return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
-    data = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Specifies what kind of attachment this is. Tells a client how to interpret
    * the `data` field. Format is namespace/type, for example
    * scrupulous-wombat-12345/welcome-message
    */
   core.String namespacedType;
 
   AttachmentInfo();
 
@@ skipping 90 matching lines @@
    * changing any of its configuration (e.g. broadcast frames, transmit power).
    * This field provides a place to store and control access to that key. This
    * field is populated in responses to `GET /v1beta1/beacons/3!beaconId` from
    * users with write access to the given beacon. That is to say: If the user is
    * authorized to write the beacon's confidential data in the service, the
    * service considers them authorized to configure the beacon. Note that this
    * key grants nothing on the service, only on the beacon itself.
    */
   core.String provisioningKey;
   core.List<core.int> get provisioningKeyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(provisioningKey);
+    return convert.BASE64.decode(provisioningKey);
   }
 
   void set provisioningKeyAsBytes(core.List<core.int> _bytes) {
-    provisioningKey = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    provisioningKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Current status of the beacon. Required.
    * Possible string values are:
    * - "STATUS_UNSPECIFIED" : A STATUS_UNSPECIFIED.
    * - "ACTIVE" : A ACTIVE.
    * - "DECOMMISSIONED" : A DECOMMISSIONED.
    * - "INACTIVE" : A INACTIVE.
    */
   core.String status;
@@ skipping 82 matching lines @@
    * beacons/beacon_id/attachments/attachment_id. Leave this empty on creation.
    */
   core.String attachmentName;
   /**
    * An opaque data container for client-provided data. Must be
    * [base64](http://tools.ietf.org/html/rfc4648#section-4) encoded in HTTP
    * requests, and will be so encoded (with padding) in responses. Required.
    */
   core.String data;
   core.List<core.int> get dataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(data);
+    return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
-    data = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Specifies what kind of attachment this is. Tells a client how to interpret
    * the `data` field. Format is namespace/type. Namespace provides type
    * separation between clients. Type describes the type of `data`, for use by
    * the client when parsing the `data` field. Required.
    */
   core.String namespacedType;
 
   BeaconAttachment();
@@ skipping 229 matching lines @@
  * at GitHub.
  */
 class EphemeralIdRegistration {
   /**
    * The beacon's public key used for the Elliptic curve Diffie-Hellman key
    * exchange. When this field is populated, `service_ecdh_public_key` must also
    * be populated, and `beacon_identity_key` must not be.
    */
   core.String beaconEcdhPublicKey;
   core.List<core.int> get beaconEcdhPublicKeyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(beaconEcdhPublicKey);
+    return convert.BASE64.decode(beaconEcdhPublicKey);
   }
 
   void set beaconEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
-    beaconEcdhPublicKey = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    beaconEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The private key of the beacon. If this field is populated,
    * `beacon_ecdh_public_key` and `service_ecdh_public_key` must not be
    * populated.
    */
   core.String beaconIdentityKey;
   core.List<core.int> get beaconIdentityKeyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(beaconIdentityKey);
+    return convert.BASE64.decode(beaconIdentityKey);
   }
 
   void set beaconIdentityKeyAsBytes(core.List<core.int> _bytes) {
-    beaconIdentityKey = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    beaconIdentityKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The initial clock value of the beacon. The beacon's clock must have begun
    * counting at this value immediately prior to transmitting this value to the
    * resolving service. Significant delay in transmitting this value to the
    * service risks registration or resolution failures. If a value is not
    * provided, the default is zero.
    */
   core.String initialClockValue;
   /**
    * An initial ephemeral ID calculated using the clock value submitted as
    * `initial_clock_value`, and the secret key generated by the Diffie-Hellman
    * key exchange using `service_ecdh_public_key` and `service_ecdh_public_key`.
    * This initial EID value will be used by the service to confirm that the key
    * exchange process was successful.
    */
   core.String initialEid;
   core.List<core.int> get initialEidAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(initialEid);
+    return convert.BASE64.decode(initialEid);
   }
 
   void set initialEidAsBytes(core.List<core.int> _bytes) {
-    initialEid = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    initialEid = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Indicates the nominal period between each rotation of the beacon's
    * ephemeral ID. "Nominal" because the beacon should randomize the actual
    * interval. See [the spec at
    * github](https://github.com/google/eddystone/tree/master/eddystone-eid) for
    * details. This value corresponds to a power-of-two scaler on the beacon's
    * clock: when the scaler value is K, the beacon will begin broadcasting a new
    * ephemeral ID on average every 2^K seconds.
    */
   core.int rotationPeriodExponent;
   /**
    * The service's public key used for the Elliptic curve Diffie-Hellman key
    * exchange. When this field is populated, `beacon_ecdh_public_key` must also
    * be populated, and `beacon_identity_key` must not be.
    */
   core.String serviceEcdhPublicKey;
   core.List<core.int> get serviceEcdhPublicKeyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(serviceEcdhPublicKey);
+    return convert.BASE64.decode(serviceEcdhPublicKey);
   }
 
   void set serviceEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
-    serviceEcdhPublicKey = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    serviceEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   EphemeralIdRegistration();
 
   EphemeralIdRegistration.fromJson(core.Map _json) {
     if (_json.containsKey("beaconEcdhPublicKey")) {
       beaconEcdhPublicKey = _json["beaconEcdhPublicKey"];
     }
     if (_json.containsKey("beaconIdentityKey")) {
       beaconIdentityKey = _json["beaconIdentityKey"];
@@ skipping 53 matching lines @@
    * Indicates the minimum rotation period supported by the service. See
    * EddystoneEidRegistration.rotation_period_exponent
    */
   core.int minRotationPeriodExponent;
   /**
    * The beacon service's public key for use by a beacon to derive its Identity
    * Key using Elliptic Curve Diffie-Hellman key exchange.
    */
   core.String serviceEcdhPublicKey;
   core.List<core.int> get serviceEcdhPublicKeyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(serviceEcdhPublicKey);
+    return convert.BASE64.decode(serviceEcdhPublicKey);
   }
 
   void set serviceEcdhPublicKeyAsBytes(core.List<core.int> _bytes) {
-    serviceEcdhPublicKey = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    serviceEcdhPublicKey = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   EphemeralIdRegistrationParams();
 
   EphemeralIdRegistrationParams.fromJson(core.Map _json) {
     if (_json.containsKey("maxRotationPeriodExponent")) {
       maxRotationPeriodExponent = _json["maxRotationPeriodExponent"];
     }
     if (_json.containsKey("minRotationPeriodExponent")) {
       minRotationPeriodExponent = _json["minRotationPeriodExponent"];
@@ skipping 340 matching lines @@
    * Required.
    */
   AdvertisedId advertisedId;
   /**
    * The array of telemetry bytes received from the beacon. The server is
    * responsible for parsing it. This field may frequently be empty, as with a
    * beacon that transmits telemetry only occasionally.
    */
   core.String telemetry;
   core.List<core.int> get telemetryAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(telemetry);
+    return convert.BASE64.decode(telemetry);
   }
 
   void set telemetryAsBytes(core.List<core.int> _bytes) {
-    telemetry = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    telemetry = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** Time when the beacon was observed. */
   core.String timestampMs;
 
   Observation();
 
   Observation.fromJson(core.Map _json) {
     if (_json.containsKey("advertisedId")) {
       advertisedId = new AdvertisedId.fromJson(_json["advertisedId"]);
     }
@@ skipping 12 matching lines @@
     }
     if (telemetry != null) {
       _json["telemetry"] = telemetry;
     }
     if (timestampMs != null) {
       _json["timestampMs"] = timestampMs;
     }
     return _json;
   }
 }