Api-roll 37: 2016-06-06

generated/googleapis/lib/safebrowsing/v4.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.safebrowsing.v4;
 
 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 safebrowsing/v4';
 
 /**
  * Enables client applications to check web resources (most commonly URLs)
  * against Google-generated lists of unsafe web resources.
@@ skipping 202 matching lines @@
 
 
 /** The expected state of a client's local database. */
 class Checksum {
   /**
    * The SHA256 hash of the client state; that is, of the sorted list of all
    * hashes present in the database.
    */
   core.String sha256;
   core.List<core.int> get sha256AsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(sha256);
+    return convert.BASE64.decode(sha256);
   }
 
   void set sha256AsBytes(core.List<core.int> _bytes) {
-    sha256 = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    sha256 = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   Checksum();
 
   Checksum.fromJson(core.Map _json) {
     if (_json.containsKey("sha256")) {
       sha256 = _json["sha256"];
     }
   }
 
@@ skipping 123 matching lines @@
     if (client != null) {
       _json["client"] = (client).toJson();
     }
     if (listUpdateRequests != null) {
       _json["listUpdateRequests"] = listUpdateRequests.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** Response type for threat list update requests. */
 class FetchThreatListUpdatesResponse {
   /** The list updates requested by the clients. */
   core.List<ListUpdateResponse> listUpdateResponses;
   /**
    * The minimum duration the client must wait before issuing any update
    * request. If this field is not set clients may update as soon as they want.
    */
   core.String minimumWaitDuration;
 
   FetchThreatListUpdatesResponse();
@@ skipping 50 matching lines @@
     if (clientStates != null) {
       _json["clientStates"] = clientStates;
     }
     if (threatInfo != null) {
       _json["threatInfo"] = (threatInfo).toJson();
     }
     return _json;
   }
 }
 
-/** Response type for requests to find full hashes. */
 class FindFullHashesResponse {
   /** The full hashes that matched the requested prefixes. */
   core.List<ThreatMatch> matches;
   /**
    * The minimum duration the client must wait before issuing any find hashes
    * request. If this field is not set, clients can issue a request as soon as
    * they want.
    */
   core.String minimumWaitDuration;
   /**
@@ skipping 54 matching lines @@
     if (client != null) {
       _json["client"] = (client).toJson();
     }
     if (threatInfo != null) {
       _json["threatInfo"] = (threatInfo).toJson();
     }
     return _json;
   }
 }
 
-/** Response type for requests to find threat matches. */
 class FindThreatMatchesResponse {
   /** The threat list matches. */
   core.List<ThreatMatch> matches;
 
   FindThreatMatchesResponse();
 
   FindThreatMatchesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("matches")) {
       matches = _json["matches"].map((value) => new ThreatMatch.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (matches != null) {
       _json["matches"] = matches.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** A collection of lists available for download by the client. */
 class ListThreatListsResponse {
   /** The lists available for download by the client. */
   core.List<ThreatListDescriptor> threatLists;
 
   ListThreatListsResponse();
 
   ListThreatListsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("threatLists")) {
       threatLists = _json["threatLists"].map((value) => new ThreatListDescriptor.fromJson(value)).toList();
     }
@@ skipping 21 matching lines @@
    * - "ANDROID" : A ANDROID.
    * - "OSX" : A OSX.
    * - "IOS" : A IOS.
    * - "ANY_PLATFORM" : A ANY_PLATFORM.
    * - "ALL_PLATFORMS" : A ALL_PLATFORMS.
    * - "CHROME" : A CHROME.
    */
   core.String platformType;
   /**
    * The current state of the client for the requested list (the encrypted
-   * ClientState that was sent to the client from the previous update request).
+   * client state that was received from the last successful list update).
    */
   core.String state;
   core.List<core.int> get stateAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(state);
+    return convert.BASE64.decode(state);
   }
 
   void set stateAsBytes(core.List<core.int> _bytes) {
-    state = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    state = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The types of entries present in the list.
    * Possible string values are:
    * - "THREAT_ENTRY_TYPE_UNSPECIFIED" : A THREAT_ENTRY_TYPE_UNSPECIFIED.
-   * - "URL_EXPRESSION" : A URL_EXPRESSION.
-   * - "BINARY_DIGEST" : A BINARY_DIGEST.
+   * - "URL" : A URL.
+   * - "EXECUTABLE" : A EXECUTABLE.
    * - "IP_RANGE" : A IP_RANGE.
    */
   core.String threatEntryType;
   /**
    * The type of threat posed by entries present in the list.
    * Possible string values are:
    * - "THREAT_TYPE_UNSPECIFIED" : A THREAT_TYPE_UNSPECIFIED.
    * - "MALWARE" : A MALWARE.
    * - "SOCIAL_ENGINEERING" : A SOCIAL_ENGINEERING.
    * - "UNWANTED_SOFTWARE" : A UNWANTED_SOFTWARE.
@@ skipping 53 matching lines @@
   /**
    * The expected SHA256 hash of the client state; that is, of the sorted list
    * of all hashes present in the database after applying the provided update.
    * If the client state doesn't match the expected state, the client must
    * disregard this update and retry later.
    */
   Checksum checksum;
   /** The new client state, in encrypted format. Opaque to clients. */
   core.String newClientState;
   core.List<core.int> get newClientStateAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(newClientState);
+    return convert.BASE64.decode(newClientState);
   }
 
   void set newClientStateAsBytes(core.List<core.int> _bytes) {
-    newClientState = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    newClientState = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The platform type for which data is returned.
    * Possible string values are:
    * - "PLATFORM_TYPE_UNSPECIFIED" : A PLATFORM_TYPE_UNSPECIFIED.
    * - "WINDOWS" : A WINDOWS.
    * - "LINUX" : A LINUX.
    * - "ANDROID" : A ANDROID.
    * - "OSX" : A OSX.
    * - "IOS" : A IOS.
@@ skipping 13 matching lines @@
    * Possible string values are:
    * - "RESPONSE_TYPE_UNSPECIFIED" : A RESPONSE_TYPE_UNSPECIFIED.
    * - "PARTIAL_UPDATE" : A PARTIAL_UPDATE.
    * - "FULL_UPDATE" : A FULL_UPDATE.
    */
   core.String responseType;
   /**
    * The format of the threats.
    * Possible string values are:
    * - "THREAT_ENTRY_TYPE_UNSPECIFIED" : A THREAT_ENTRY_TYPE_UNSPECIFIED.
-   * - "URL_EXPRESSION" : A URL_EXPRESSION.
-   * - "BINARY_DIGEST" : A BINARY_DIGEST.
+   * - "URL" : A URL.
+   * - "EXECUTABLE" : A EXECUTABLE.
    * - "IP_RANGE" : A IP_RANGE.
    */
   core.String threatEntryType;
   /**
    * The threat type for which data is returned.
    * Possible string values are:
    * - "THREAT_TYPE_UNSPECIFIED" : A THREAT_TYPE_UNSPECIFIED.
    * - "MALWARE" : A MALWARE.
    * - "SOCIAL_ENGINEERING" : A SOCIAL_ENGINEERING.
    * - "UNWANTED_SOFTWARE" : A UNWANTED_SOFTWARE.
@@ skipping 58 matching lines @@
     }
     return _json;
   }
 }
 
 /** A single metadata entry. */
 class MetadataEntry {
   /** The metadata entry key. */
   core.String key;
   core.List<core.int> get keyAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(key);
+    return convert.BASE64.decode(key);
   }
 
   void set keyAsBytes(core.List<core.int> _bytes) {
-    key = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    key = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** The metadata entry value. */
   core.String value;
   core.List<core.int> get valueAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(value);
+    return convert.BASE64.decode(value);
   }
 
   void set valueAsBytes(core.List<core.int> _bytes) {
-    value = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    value = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   MetadataEntry();
 
   MetadataEntry.fromJson(core.Map _json) {
     if (_json.containsKey("key")) {
       key = _json["key"];
     }
     if (_json.containsKey("value")) {
       value = _json["value"];
@@ skipping 25 matching lines @@
    * The number of bytes for each prefix encoded below. This field can be
    * anywhere from 4 (shortest prefix) to 32 (full SHA256 hash).
    */
   core.int prefixSize;
   /**
    * The hashes, all concatenated into one long string. Each hash has a prefix
    * size of |prefix_size| above. Hashes are sorted in lexicographic order.
    */
   core.String rawHashes;
   core.List<core.int> get rawHashesAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(rawHashes);
+    return convert.BASE64.decode(rawHashes);
   }
 
   void set rawHashesAsBytes(core.List<core.int> _bytes) {
-    rawHashes = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    rawHashes = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
 
   RawHashes();
 
   RawHashes.fromJson(core.Map _json) {
     if (_json.containsKey("prefixSize")) {
       prefixSize = _json["prefixSize"];
     }
     if (_json.containsKey("rawHashes")) {
       rawHashes = _json["rawHashes"];
@@ skipping 35 matching lines @@
 }
 
 /**
  * The Rice-Golomb encoded data. Used for sending compressed 4-byte hashes or
  * compressed removal indices.
  */
 class RiceDeltaEncoding {
   /** The encoded deltas that are encoded using the Golomb-Rice coder. */
   core.String encodedData;
   core.List<core.int> get encodedDataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(encodedData);
+    return convert.BASE64.decode(encodedData);
   }
 
   void set encodedDataAsBytes(core.List<core.int> _bytes) {
-    encodedData = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    encodedData = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * The offset of the first entry in the encoded data, or, if only a single
    * integer was encoded, that single integer's value.
    */
   core.String firstValue;
   /**
    * The number of entries that are delta encoded in the encoded data. If only a
    * single integer was encoded, this will be zero and the single value will be
-   * stored in first_value.
+   * stored in `first_value`.
    */
   core.int numEntries;
   /**
-   * The Golomb-Rice parameter which is a number between 2 and 28. This field is
-   * missing (that is, zero) if num_entries is zero.
+   * The Golomb-Rice parameter, which is a number between 2 and 28. This field
+   * is missing (that is, zero) if `num_entries` is zero.
    */
   core.int riceParameter;
 
   RiceDeltaEncoding();
 
   RiceDeltaEncoding.fromJson(core.Map _json) {
     if (_json.containsKey("encodedData")) {
       encodedData = _json["encodedData"];
     }
     if (_json.containsKey("firstValue")) {
@@ skipping 24 matching lines @@
     return _json;
   }
 }
 
 /**
  * An individual threat; for example, a malicious URL or its hash
  * representation. Only one of these fields should be set.
  */
 class ThreatEntry {
   /**
+   * The digest of an executable in SHA256 format. The API supports both binary
+   * and hex digests.
+   */
+  core.String digest;
+  core.List<core.int> get digestAsBytes {
+    return convert.BASE64.decode(digest);
+  }
+
+  void set digestAsBytes(core.List<core.int> _bytes) {
+    digest = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
+  }
+  /**
    * A hash prefix, consisting of the most significant 4-32 bytes of a SHA256
-   * hash.
+   * hash. This field is in binary format.
    */
   core.String hash;
   core.List<core.int> get hashAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(hash);
+    return convert.BASE64.decode(hash);
   }
 
   void set hashAsBytes(core.List<core.int> _bytes) {
-    hash = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    hash = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** A URL. */
   core.String url;
 
   ThreatEntry();
 
   ThreatEntry.fromJson(core.Map _json) {
+    if (_json.containsKey("digest")) {
+      digest = _json["digest"];
+    }
     if (_json.containsKey("hash")) {
       hash = _json["hash"];
     }
     if (_json.containsKey("url")) {
       url = _json["url"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (digest != null) {
+      _json["digest"] = digest;
+    }
     if (hash != null) {
       _json["hash"] = hash;
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
@@ skipping 157 matching lines @@
    * - "IOS" : A IOS.
    * - "ANY_PLATFORM" : A ANY_PLATFORM.
    * - "ALL_PLATFORMS" : A ALL_PLATFORMS.
    * - "CHROME" : A CHROME.
    */
   core.String platformType;
   /**
    * The entry types contained in the list.
    * Possible string values are:
    * - "THREAT_ENTRY_TYPE_UNSPECIFIED" : A THREAT_ENTRY_TYPE_UNSPECIFIED.
-   * - "URL_EXPRESSION" : A URL_EXPRESSION.
-   * - "BINARY_DIGEST" : A BINARY_DIGEST.
+   * - "URL" : A URL.
+   * - "EXECUTABLE" : A EXECUTABLE.
    * - "IP_RANGE" : A IP_RANGE.
    */
   core.String threatEntryType;
   /**
    * The threat type posed by the list's entries.
    * Possible string values are:
    * - "THREAT_TYPE_UNSPECIFIED" : A THREAT_TYPE_UNSPECIFIED.
    * - "MALWARE" : A MALWARE.
    * - "SOCIAL_ENGINEERING" : A SOCIAL_ENGINEERING.
    * - "UNWANTED_SOFTWARE" : A UNWANTED_SOFTWARE.
@@ skipping 52 matching lines @@
    */
   core.String platformType;
   /** The threat matching this threat. */
   ThreatEntry threat;
   /** Optional metadata associated with this threat. */
   ThreatEntryMetadata threatEntryMetadata;
   /**
    * The threat entry type matching this threat.
    * Possible string values are:
    * - "THREAT_ENTRY_TYPE_UNSPECIFIED" : A THREAT_ENTRY_TYPE_UNSPECIFIED.
-   * - "URL_EXPRESSION" : A URL_EXPRESSION.
-   * - "BINARY_DIGEST" : A BINARY_DIGEST.
+   * - "URL" : A URL.
+   * - "EXECUTABLE" : A EXECUTABLE.
    * - "IP_RANGE" : A IP_RANGE.
    */
   core.String threatEntryType;
   /**
    * The threat type matching this threat.
    * Possible string values are:
    * - "THREAT_TYPE_UNSPECIFIED" : A THREAT_TYPE_UNSPECIFIED.
    * - "MALWARE" : A MALWARE.
    * - "SOCIAL_ENGINEERING" : A SOCIAL_ENGINEERING.
    * - "UNWANTED_SOFTWARE" : A UNWANTED_SOFTWARE.
@@ skipping 40 matching lines @@
     }
     if (threatEntryType != null) {
       _json["threatEntryType"] = threatEntryType;
     }
     if (threatType != null) {
       _json["threatType"] = threatType;
     }
     return _json;
   }
 }